Add decompiled APK source code (JADX)

- 28,932 files
- Full Java source code
- Smali files
- Resources

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

decompiled/sources/com/mbridge/msdk/thrid/okhttp/Address.java

@@ -0,0 +1,146 @@
+package com.mbridge.msdk.thrid.okhttp;
+
+import com.facebook.internal.security.CertificateUtil;
+import com.ironsource.mediationsdk.logger.IronSourceError;
+import com.mbridge.msdk.thrid.okhttp.HttpUrl;
+import com.mbridge.msdk.thrid.okhttp.internal.Util;
+import java.net.Proxy;
+import java.net.ProxySelector;
+import java.util.List;
+import javax.net.SocketFactory;
+import javax.net.ssl.HostnameVerifier;
+import javax.net.ssl.SSLSocketFactory;
+
+/* loaded from: classes4.dex */
+public final class Address {
+    final CertificatePinner certificatePinner;
+    final List<ConnectionSpec> connectionSpecs;
+    final Dns dns;
+    final HostnameVerifier hostnameVerifier;
+    final List<Protocol> protocols;
+    final Proxy proxy;
+    final Authenticator proxyAuthenticator;
+    final ProxySelector proxySelector;
+    final SocketFactory socketFactory;
+    final SSLSocketFactory sslSocketFactory;
+    final HttpUrl url;
+
+    public CertificatePinner certificatePinner() {
+        return this.certificatePinner;
+    }
+
+    public List<ConnectionSpec> connectionSpecs() {
+        return this.connectionSpecs;
+    }
+
+    public Dns dns() {
+        return this.dns;
+    }
+
+    public HostnameVerifier hostnameVerifier() {
+        return this.hostnameVerifier;
+    }
+
+    public List<Protocol> protocols() {
+        return this.protocols;
+    }
+
+    public Proxy proxy() {
+        return this.proxy;
+    }
+
+    public Authenticator proxyAuthenticator() {
+        return this.proxyAuthenticator;
+    }
+
+    public ProxySelector proxySelector() {
+        return this.proxySelector;
+    }
+
+    public SocketFactory socketFactory() {
+        return this.socketFactory;
+    }
+
+    public SSLSocketFactory sslSocketFactory() {
+        return this.sslSocketFactory;
+    }
+
+    public HttpUrl url() {
+        return this.url;
+    }
+
+    public Address(String str, int i, Dns dns, SocketFactory socketFactory, SSLSocketFactory sSLSocketFactory, HostnameVerifier hostnameVerifier, CertificatePinner certificatePinner, Authenticator authenticator, Proxy proxy, List<Protocol> list, List<ConnectionSpec> list2, ProxySelector proxySelector) {
+        this.url = new HttpUrl.Builder().scheme(sSLSocketFactory != null ? "https" : "http").host(str).port(i).build();
+        if (dns == null) {
+            throw new NullPointerException("dns == null");
+        }
+        this.dns = dns;
+        if (socketFactory == null) {
+            throw new NullPointerException("socketFactory == null");
+        }
+        this.socketFactory = socketFactory;
+        if (authenticator == null) {
+            throw new NullPointerException("proxyAuthenticator == null");
+        }
+        this.proxyAuthenticator = authenticator;
+        if (list == null) {
+            throw new NullPointerException("protocols == null");
+        }
+        this.protocols = Util.immutableList(list);
+        if (list2 == null) {
+            throw new NullPointerException("connectionSpecs == null");
+        }
+        this.connectionSpecs = Util.immutableList(list2);
+        if (proxySelector == null) {
+            throw new NullPointerException("proxySelector == null");
+        }
+        this.proxySelector = proxySelector;
+        this.proxy = proxy;
+        this.sslSocketFactory = sSLSocketFactory;
+        this.hostnameVerifier = hostnameVerifier;
+        this.certificatePinner = certificatePinner;
+    }
+
+    public boolean equals(Object obj) {
+        if (obj instanceof Address) {
+            Address address = (Address) obj;
+            if (this.url.equals(address.url) && equalsNonHost(address)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public int hashCode() {
+        int hashCode = (((((((((((IronSourceError.ERROR_NON_EXISTENT_INSTANCE + this.url.hashCode()) * 31) + this.dns.hashCode()) * 31) + this.proxyAuthenticator.hashCode()) * 31) + this.protocols.hashCode()) * 31) + this.connectionSpecs.hashCode()) * 31) + this.proxySelector.hashCode()) * 31;
+        Proxy proxy = this.proxy;
+        int hashCode2 = (hashCode + (proxy != null ? proxy.hashCode() : 0)) * 31;
+        SSLSocketFactory sSLSocketFactory = this.sslSocketFactory;
+        int hashCode3 = (hashCode2 + (sSLSocketFactory != null ? sSLSocketFactory.hashCode() : 0)) * 31;
+        HostnameVerifier hostnameVerifier = this.hostnameVerifier;
+        int hashCode4 = (hashCode3 + (hostnameVerifier != null ? hostnameVerifier.hashCode() : 0)) * 31;
+        CertificatePinner certificatePinner = this.certificatePinner;
+        return hashCode4 + (certificatePinner != null ? certificatePinner.hashCode() : 0);
+    }
+
+    public boolean equalsNonHost(Address address) {
+        return this.dns.equals(address.dns) && this.proxyAuthenticator.equals(address.proxyAuthenticator) && this.protocols.equals(address.protocols) && this.connectionSpecs.equals(address.connectionSpecs) && this.proxySelector.equals(address.proxySelector) && Util.equal(this.proxy, address.proxy) && Util.equal(this.sslSocketFactory, address.sslSocketFactory) && Util.equal(this.hostnameVerifier, address.hostnameVerifier) && Util.equal(this.certificatePinner, address.certificatePinner) && url().port() == address.url().port();
+    }
+
+    public String toString() {
+        StringBuilder sb = new StringBuilder();
+        sb.append("Address{");
+        sb.append(this.url.host());
+        sb.append(CertificateUtil.DELIMITER);
+        sb.append(this.url.port());
+        if (this.proxy != null) {
+            sb.append(", proxy=");
+            sb.append(this.proxy);
+        } else {
+            sb.append(", proxySelector=");
+            sb.append(this.proxySelector);
+        }
+        sb.append("}");
+        return sb.toString();
+    }
+}

decompiled/sources/com/mbridge/msdk/thrid/okhttp/Authenticator.java

@@ -0,0 +1,15 @@
+package com.mbridge.msdk.thrid.okhttp;
+
+import java.io.IOException;
+
+/* loaded from: classes4.dex */
+public interface Authenticator {
+    public static final Authenticator NONE = new Authenticator() { // from class: com.mbridge.msdk.thrid.okhttp.Authenticator.1
+        @Override // com.mbridge.msdk.thrid.okhttp.Authenticator
+        public Request authenticate(Route route, Response response) {
+            return null;
+        }
+    };
+
+    Request authenticate(Route route, Response response) throws IOException;
+}

decompiled/sources/com/mbridge/msdk/thrid/okhttp/Cache.java

@@ -0,0 +1,569 @@
+package com.mbridge.msdk.thrid.okhttp;
+
+import com.mbridge.msdk.thrid.okhttp.Headers;
+import com.mbridge.msdk.thrid.okhttp.Request;
+import com.mbridge.msdk.thrid.okhttp.Response;
+import com.mbridge.msdk.thrid.okhttp.internal.Util;
+import com.mbridge.msdk.thrid.okhttp.internal.cache.CacheRequest;
+import com.mbridge.msdk.thrid.okhttp.internal.cache.CacheStrategy;
+import com.mbridge.msdk.thrid.okhttp.internal.cache.DiskLruCache;
+import com.mbridge.msdk.thrid.okhttp.internal.cache.InternalCache;
+import com.mbridge.msdk.thrid.okhttp.internal.http.HttpHeaders;
+import com.mbridge.msdk.thrid.okhttp.internal.http.HttpMethod;
+import com.mbridge.msdk.thrid.okhttp.internal.http.StatusLine;
+import com.mbridge.msdk.thrid.okhttp.internal.io.FileSystem;
+import com.mbridge.msdk.thrid.okhttp.internal.platform.Platform;
+import com.mbridge.msdk.thrid.okio.Buffer;
+import com.mbridge.msdk.thrid.okio.BufferedSink;
+import com.mbridge.msdk.thrid.okio.BufferedSource;
+import com.mbridge.msdk.thrid.okio.ByteString;
+import com.mbridge.msdk.thrid.okio.ForwardingSink;
+import com.mbridge.msdk.thrid.okio.ForwardingSource;
+import com.mbridge.msdk.thrid.okio.Okio;
+import com.mbridge.msdk.thrid.okio.Sink;
+import com.mbridge.msdk.thrid.okio.Source;
+import com.unity3d.ads.core.data.datasource.AndroidStaticDeviceInfoDataSource;
+import java.io.Closeable;
+import java.io.File;
+import java.io.Flushable;
+import java.io.IOException;
+import java.security.cert.Certificate;
+import java.security.cert.CertificateEncodingException;
+import java.security.cert.CertificateException;
+import java.security.cert.CertificateFactory;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.List;
+import java.util.NoSuchElementException;
+import org.apache.http.protocol.HTTP;
+
+/* loaded from: classes4.dex */
+public final class Cache implements Closeable, Flushable {
+    private static final int ENTRY_BODY = 1;
+    private static final int ENTRY_COUNT = 2;
+    private static final int ENTRY_METADATA = 0;
+    private static final int VERSION = 201105;
+    final DiskLruCache cache;
+    private int hitCount;
+    final InternalCache internalCache;
+    private int networkCount;
+    private int requestCount;
+    int writeAbortCount;
+    int writeSuccessCount;
+
+    public Cache(File file, long j) {
+        this(file, j, FileSystem.SYSTEM);
+    }
+
+    public Cache(File file, long j, FileSystem fileSystem) {
+        this.internalCache = new InternalCache() { // from class: com.mbridge.msdk.thrid.okhttp.Cache.1
+            @Override // com.mbridge.msdk.thrid.okhttp.internal.cache.InternalCache
+            public Response get(Request request) throws IOException {
+                return Cache.this.get(request);
+            }
+
+            @Override // com.mbridge.msdk.thrid.okhttp.internal.cache.InternalCache
+            public CacheRequest put(Response response) throws IOException {
+                return Cache.this.put(response);
+            }
+
+            @Override // com.mbridge.msdk.thrid.okhttp.internal.cache.InternalCache
+            public void remove(Request request) throws IOException {
+                Cache.this.remove(request);
+            }
+
+            @Override // com.mbridge.msdk.thrid.okhttp.internal.cache.InternalCache
+            public void update(Response response, Response response2) {
+                Cache.this.update(response, response2);
+            }
+
+            @Override // com.mbridge.msdk.thrid.okhttp.internal.cache.InternalCache
+            public void trackConditionalCacheHit() {
+                Cache.this.trackConditionalCacheHit();
+            }
+
+            @Override // com.mbridge.msdk.thrid.okhttp.internal.cache.InternalCache
+            public void trackResponse(CacheStrategy cacheStrategy) {
+                Cache.this.trackResponse(cacheStrategy);
+            }
+        };
+        this.cache = DiskLruCache.create(fileSystem, file, VERSION, 2, j);
+    }
+
+    public static String key(HttpUrl httpUrl) {
+        return ByteString.encodeUtf8(httpUrl.toString()).md5().hex();
+    }
+
+    public Response get(Request request) {
+        try {
+            DiskLruCache.Snapshot snapshot = this.cache.get(key(request.url()));
+            if (snapshot == null) {
+                return null;
+            }
+            try {
+                Entry entry = new Entry(snapshot.getSource(0));
+                Response response = entry.response(snapshot);
+                if (entry.matches(request, response)) {
+                    return response;
+                }
+                Util.closeQuietly(response.body());
+                return null;
+            } catch (IOException unused) {
+                Util.closeQuietly(snapshot);
+                return null;
+            }
+        } catch (IOException unused2) {
+        }
+    }
+
+    public CacheRequest put(Response response) {
+        DiskLruCache.Editor editor;
+        String method = response.request().method();
+        if (HttpMethod.invalidatesCache(response.request().method())) {
+            try {
+                remove(response.request());
+            } catch (IOException unused) {
+            }
+            return null;
+        }
+        if (!method.equals("GET") || HttpHeaders.hasVaryAll(response)) {
+            return null;
+        }
+        Entry entry = new Entry(response);
+        try {
+            editor = this.cache.edit(key(response.request().url()));
+            if (editor == null) {
+                return null;
+            }
+            try {
+                entry.writeTo(editor);
+                return new CacheRequestImpl(editor);
+            } catch (IOException unused2) {
+                abortQuietly(editor);
+                return null;
+            }
+        } catch (IOException unused3) {
+            editor = null;
+        }
+    }
+
+    public void remove(Request request) throws IOException {
+        this.cache.remove(key(request.url()));
+    }
+
+    public void update(Response response, Response response2) {
+        DiskLruCache.Editor editor;
+        Entry entry = new Entry(response2);
+        try {
+            editor = ((CacheResponseBody) response.body()).snapshot.edit();
+            if (editor != null) {
+                try {
+                    entry.writeTo(editor);
+                    editor.commit();
+                } catch (IOException unused) {
+                    abortQuietly(editor);
+                }
+            }
+        } catch (IOException unused2) {
+            editor = null;
+        }
+    }
+
+    private void abortQuietly(DiskLruCache.Editor editor) {
+        if (editor != null) {
+            try {
+                editor.abort();
+            } catch (IOException unused) {
+            }
+        }
+    }
+
+    public void initialize() throws IOException {
+        this.cache.initialize();
+    }
+
+    public void delete() throws IOException {
+        this.cache.delete();
+    }
+
+    public void evictAll() throws IOException {
+        this.cache.evictAll();
+    }
+
+    public Iterator<String> urls() throws IOException {
+        return new Iterator<String>() { // from class: com.mbridge.msdk.thrid.okhttp.Cache.2
+            boolean canRemove;
+            final Iterator<DiskLruCache.Snapshot> delegate;
+            String nextUrl;
+
+            {
+                this.delegate = Cache.this.cache.snapshots();
+            }
+
+            @Override // java.util.Iterator
+            public boolean hasNext() {
+                if (this.nextUrl != null) {
+                    return true;
+                }
+                this.canRemove = false;
+                while (this.delegate.hasNext()) {
+                    DiskLruCache.Snapshot next = this.delegate.next();
+                    try {
+                        this.nextUrl = Okio.buffer(next.getSource(0)).readUtf8LineStrict();
+                        return true;
+                    } catch (IOException unused) {
+                    } finally {
+                        next.close();
+                    }
+                }
+                return false;
+            }
+
+            @Override // java.util.Iterator
+            public String next() {
+                if (!hasNext()) {
+                    throw new NoSuchElementException();
+                }
+                String str = this.nextUrl;
+                this.nextUrl = null;
+                this.canRemove = true;
+                return str;
+            }
+
+            @Override // java.util.Iterator
+            public void remove() {
+                if (!this.canRemove) {
+                    throw new IllegalStateException("remove() before next()");
+                }
+                this.delegate.remove();
+            }
+        };
+    }
+
+    public synchronized int writeAbortCount() {
+        return this.writeAbortCount;
+    }
+
+    public synchronized int writeSuccessCount() {
+        return this.writeSuccessCount;
+    }
+
+    public long size() throws IOException {
+        return this.cache.size();
+    }
+
+    public long maxSize() {
+        return this.cache.getMaxSize();
+    }
+
+    @Override // java.io.Flushable
+    public void flush() throws IOException {
+        this.cache.flush();
+    }
+
+    @Override // java.io.Closeable, java.lang.AutoCloseable
+    public void close() throws IOException {
+        this.cache.close();
+    }
+
+    public File directory() {
+        return this.cache.getDirectory();
+    }
+
+    public boolean isClosed() {
+        return this.cache.isClosed();
+    }
+
+    public synchronized void trackResponse(CacheStrategy cacheStrategy) {
+        try {
+            this.requestCount++;
+            if (cacheStrategy.networkRequest != null) {
+                this.networkCount++;
+            } else if (cacheStrategy.cacheResponse != null) {
+                this.hitCount++;
+            }
+        } catch (Throwable th) {
+            throw th;
+        }
+    }
+
+    public synchronized void trackConditionalCacheHit() {
+        this.hitCount++;
+    }
+
+    public synchronized int networkCount() {
+        return this.networkCount;
+    }
+
+    public synchronized int hitCount() {
+        return this.hitCount;
+    }
+
+    public synchronized int requestCount() {
+        return this.requestCount;
+    }
+
+    public final class CacheRequestImpl implements CacheRequest {
+        private Sink body;
+        private Sink cacheOut;
+        boolean done;
+        private final DiskLruCache.Editor editor;
+
+        @Override // com.mbridge.msdk.thrid.okhttp.internal.cache.CacheRequest
+        public Sink body() {
+            return this.body;
+        }
+
+        public CacheRequestImpl(final DiskLruCache.Editor editor) {
+            this.editor = editor;
+            Sink newSink = editor.newSink(1);
+            this.cacheOut = newSink;
+            this.body = new ForwardingSink(newSink) { // from class: com.mbridge.msdk.thrid.okhttp.Cache.CacheRequestImpl.1
+                @Override // com.mbridge.msdk.thrid.okio.ForwardingSink, com.mbridge.msdk.thrid.okio.Sink, java.io.Closeable, java.lang.AutoCloseable
+                public void close() throws IOException {
+                    synchronized (Cache.this) {
+                        try {
+                            CacheRequestImpl cacheRequestImpl = CacheRequestImpl.this;
+                            if (cacheRequestImpl.done) {
+                                return;
+                            }
+                            cacheRequestImpl.done = true;
+                            Cache.this.writeSuccessCount++;
+                            super.close();
+                            editor.commit();
+                        } catch (Throwable th) {
+                            throw th;
+                        }
+                    }
+                }
+            };
+        }
+
+        @Override // com.mbridge.msdk.thrid.okhttp.internal.cache.CacheRequest
+        public void abort() {
+            synchronized (Cache.this) {
+                try {
+                    if (this.done) {
+                        return;
+                    }
+                    this.done = true;
+                    Cache.this.writeAbortCount++;
+                    Util.closeQuietly(this.cacheOut);
+                    try {
+                        this.editor.abort();
+                    } catch (IOException unused) {
+                    }
+                } catch (Throwable th) {
+                    throw th;
+                }
+            }
+        }
+    }
+
+    public static final class Entry {
+        private final int code;
+        private final Handshake handshake;
+        private final String message;
+        private final Protocol protocol;
+        private final long receivedResponseMillis;
+        private final String requestMethod;
+        private final Headers responseHeaders;
+        private final long sentRequestMillis;
+        private final String url;
+        private final Headers varyHeaders;
+        private static final String SENT_MILLIS = Platform.get().getPrefix() + "-Sent-Millis";
+        private static final String RECEIVED_MILLIS = Platform.get().getPrefix() + "-Received-Millis";
+
+        public Entry(Source source) throws IOException {
+            try {
+                BufferedSource buffer = Okio.buffer(source);
+                this.url = buffer.readUtf8LineStrict();
+                this.requestMethod = buffer.readUtf8LineStrict();
+                Headers.Builder builder = new Headers.Builder();
+                int readInt = Cache.readInt(buffer);
+                for (int i = 0; i < readInt; i++) {
+                    builder.addLenient(buffer.readUtf8LineStrict());
+                }
+                this.varyHeaders = builder.build();
+                StatusLine parse = StatusLine.parse(buffer.readUtf8LineStrict());
+                this.protocol = parse.protocol;
+                this.code = parse.code;
+                this.message = parse.message;
+                Headers.Builder builder2 = new Headers.Builder();
+                int readInt2 = Cache.readInt(buffer);
+                for (int i2 = 0; i2 < readInt2; i2++) {
+                    builder2.addLenient(buffer.readUtf8LineStrict());
+                }
+                String str = SENT_MILLIS;
+                String str2 = builder2.get(str);
+                String str3 = RECEIVED_MILLIS;
+                String str4 = builder2.get(str3);
+                builder2.removeAll(str);
+                builder2.removeAll(str3);
+                this.sentRequestMillis = str2 != null ? Long.parseLong(str2) : 0L;
+                this.receivedResponseMillis = str4 != null ? Long.parseLong(str4) : 0L;
+                this.responseHeaders = builder2.build();
+                if (isHttps()) {
+                    String readUtf8LineStrict = buffer.readUtf8LineStrict();
+                    if (readUtf8LineStrict.length() > 0) {
+                        throw new IOException("expected \"\" but was \"" + readUtf8LineStrict + "\"");
+                    }
+                    this.handshake = Handshake.get(!buffer.exhausted() ? TlsVersion.forJavaName(buffer.readUtf8LineStrict()) : TlsVersion.SSL_3_0, CipherSuite.forJavaName(buffer.readUtf8LineStrict()), readCertificateList(buffer), readCertificateList(buffer));
+                } else {
+                    this.handshake = null;
+                }
+                source.close();
+            } catch (Throwable th) {
+                source.close();
+                throw th;
+            }
+        }
+
+        public Entry(Response response) {
+            this.url = response.request().url().toString();
+            this.varyHeaders = HttpHeaders.varyHeaders(response);
+            this.requestMethod = response.request().method();
+            this.protocol = response.protocol();
+            this.code = response.code();
+            this.message = response.message();
+            this.responseHeaders = response.headers();
+            this.handshake = response.handshake();
+            this.sentRequestMillis = response.sentRequestAtMillis();
+            this.receivedResponseMillis = response.receivedResponseAtMillis();
+        }
+
+        public void writeTo(DiskLruCache.Editor editor) throws IOException {
+            BufferedSink buffer = Okio.buffer(editor.newSink(0));
+            buffer.writeUtf8(this.url).writeByte(10);
+            buffer.writeUtf8(this.requestMethod).writeByte(10);
+            buffer.writeDecimalLong(this.varyHeaders.size()).writeByte(10);
+            int size = this.varyHeaders.size();
+            for (int i = 0; i < size; i++) {
+                buffer.writeUtf8(this.varyHeaders.name(i)).writeUtf8(": ").writeUtf8(this.varyHeaders.value(i)).writeByte(10);
+            }
+            buffer.writeUtf8(new StatusLine(this.protocol, this.code, this.message).toString()).writeByte(10);
+            buffer.writeDecimalLong(this.responseHeaders.size() + 2).writeByte(10);
+            int size2 = this.responseHeaders.size();
+            for (int i2 = 0; i2 < size2; i2++) {
+                buffer.writeUtf8(this.responseHeaders.name(i2)).writeUtf8(": ").writeUtf8(this.responseHeaders.value(i2)).writeByte(10);
+            }
+            buffer.writeUtf8(SENT_MILLIS).writeUtf8(": ").writeDecimalLong(this.sentRequestMillis).writeByte(10);
+            buffer.writeUtf8(RECEIVED_MILLIS).writeUtf8(": ").writeDecimalLong(this.receivedResponseMillis).writeByte(10);
+            if (isHttps()) {
+                buffer.writeByte(10);
+                buffer.writeUtf8(this.handshake.cipherSuite().javaName()).writeByte(10);
+                writeCertList(buffer, this.handshake.peerCertificates());
+                writeCertList(buffer, this.handshake.localCertificates());
+                buffer.writeUtf8(this.handshake.tlsVersion().javaName()).writeByte(10);
+            }
+            buffer.close();
+        }
+
+        private boolean isHttps() {
+            return this.url.startsWith("https://");
+        }
+
+        private List<Certificate> readCertificateList(BufferedSource bufferedSource) throws IOException {
+            int readInt = Cache.readInt(bufferedSource);
+            if (readInt == -1) {
+                return Collections.emptyList();
+            }
+            try {
+                CertificateFactory certificateFactory = CertificateFactory.getInstance(AndroidStaticDeviceInfoDataSource.CERTIFICATE_TYPE_X509);
+                ArrayList arrayList = new ArrayList(readInt);
+                for (int i = 0; i < readInt; i++) {
+                    String readUtf8LineStrict = bufferedSource.readUtf8LineStrict();
+                    Buffer buffer = new Buffer();
+                    buffer.write(ByteString.decodeBase64(readUtf8LineStrict));
+                    arrayList.add(certificateFactory.generateCertificate(buffer.inputStream()));
+                }
+                return arrayList;
+            } catch (CertificateException e) {
+                throw new IOException(e.getMessage());
+            }
+        }
+
+        private void writeCertList(BufferedSink bufferedSink, List<Certificate> list) throws IOException {
+            try {
+                bufferedSink.writeDecimalLong(list.size()).writeByte(10);
+                int size = list.size();
+                for (int i = 0; i < size; i++) {
+                    bufferedSink.writeUtf8(ByteString.of(list.get(i).getEncoded()).base64()).writeByte(10);
+                }
+            } catch (CertificateEncodingException e) {
+                throw new IOException(e.getMessage());
+            }
+        }
+
+        public boolean matches(Request request, Response response) {
+            return this.url.equals(request.url().toString()) && this.requestMethod.equals(request.method()) && HttpHeaders.varyMatches(response, this.varyHeaders, request);
+        }
+
+        public Response response(DiskLruCache.Snapshot snapshot) {
+            String str = this.responseHeaders.get("Content-Type");
+            String str2 = this.responseHeaders.get(HTTP.CONTENT_LEN);
+            return new Response.Builder().request(new Request.Builder().url(this.url).method(this.requestMethod, null).headers(this.varyHeaders).build()).protocol(this.protocol).code(this.code).message(this.message).headers(this.responseHeaders).body(new CacheResponseBody(snapshot, str, str2)).handshake(this.handshake).sentRequestAtMillis(this.sentRequestMillis).receivedResponseAtMillis(this.receivedResponseMillis).build();
+        }
+    }
+
+    public static int readInt(BufferedSource bufferedSource) throws IOException {
+        try {
+            long readDecimalLong = bufferedSource.readDecimalLong();
+            String readUtf8LineStrict = bufferedSource.readUtf8LineStrict();
+            if (readDecimalLong >= 0 && readDecimalLong <= 2147483647L && readUtf8LineStrict.isEmpty()) {
+                return (int) readDecimalLong;
+            }
+            throw new IOException("expected an int but was \"" + readDecimalLong + readUtf8LineStrict + "\"");
+        } catch (NumberFormatException e) {
+            throw new IOException(e.getMessage());
+        }
+    }
+
+    public static class CacheResponseBody extends ResponseBody {
+        private final BufferedSource bodySource;
+        private final String contentLength;
+        private final String contentType;
+        final DiskLruCache.Snapshot snapshot;
+
+        @Override // com.mbridge.msdk.thrid.okhttp.ResponseBody
+        public BufferedSource source() {
+            return this.bodySource;
+        }
+
+        public CacheResponseBody(final DiskLruCache.Snapshot snapshot, String str, String str2) {
+            this.snapshot = snapshot;
+            this.contentType = str;
+            this.contentLength = str2;
+            this.bodySource = Okio.buffer(new ForwardingSource(snapshot.getSource(1)) { // from class: com.mbridge.msdk.thrid.okhttp.Cache.CacheResponseBody.1
+                @Override // com.mbridge.msdk.thrid.okio.ForwardingSource, com.mbridge.msdk.thrid.okio.Source, java.io.Closeable, java.lang.AutoCloseable
+                public void close() throws IOException {
+                    snapshot.close();
+                    super.close();
+                }
+            });
+        }
+
+        @Override // com.mbridge.msdk.thrid.okhttp.ResponseBody
+        public MediaType contentType() {
+            String str = this.contentType;
+            if (str != null) {
+                return MediaType.parse(str);
+            }
+            return null;
+        }
+
+        @Override // com.mbridge.msdk.thrid.okhttp.ResponseBody
+        public long contentLength() {
+            try {
+                String str = this.contentLength;
+                if (str != null) {
+                    return Long.parseLong(str);
+                }
+                return -1L;
+            } catch (NumberFormatException unused) {
+                return -1L;
+            }
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/thrid/okhttp/CacheControl.java

@@ -0,0 +1,244 @@
+package com.mbridge.msdk.thrid.okhttp;
+
+import java.util.concurrent.TimeUnit;
+
+/* loaded from: classes4.dex */
+public final class CacheControl {
+    String headerValue;
+    private final boolean immutable;
+    private final boolean isPrivate;
+    private final boolean isPublic;
+    private final int maxAgeSeconds;
+    private final int maxStaleSeconds;
+    private final int minFreshSeconds;
+    private final boolean mustRevalidate;
+    private final boolean noCache;
+    private final boolean noStore;
+    private final boolean noTransform;
+    private final boolean onlyIfCached;
+    private final int sMaxAgeSeconds;
+    public static final CacheControl FORCE_NETWORK = new Builder().noCache().build();
+    public static final CacheControl FORCE_CACHE = new Builder().onlyIfCached().maxStale(Integer.MAX_VALUE, TimeUnit.SECONDS).build();
+
+    public boolean immutable() {
+        return this.immutable;
+    }
+
+    public boolean isPrivate() {
+        return this.isPrivate;
+    }
+
+    public boolean isPublic() {
+        return this.isPublic;
+    }
+
+    public int maxAgeSeconds() {
+        return this.maxAgeSeconds;
+    }
+
+    public int maxStaleSeconds() {
+        return this.maxStaleSeconds;
+    }
+
+    public int minFreshSeconds() {
+        return this.minFreshSeconds;
+    }
+
+    public boolean mustRevalidate() {
+        return this.mustRevalidate;
+    }
+
+    public boolean noCache() {
+        return this.noCache;
+    }
+
+    public boolean noStore() {
+        return this.noStore;
+    }
+
+    public boolean noTransform() {
+        return this.noTransform;
+    }
+
+    public boolean onlyIfCached() {
+        return this.onlyIfCached;
+    }
+
+    public int sMaxAgeSeconds() {
+        return this.sMaxAgeSeconds;
+    }
+
+    private CacheControl(boolean z, boolean z2, int i, int i2, boolean z3, boolean z4, boolean z5, int i3, int i4, boolean z6, boolean z7, boolean z8, String str) {
+        this.noCache = z;
+        this.noStore = z2;
+        this.maxAgeSeconds = i;
+        this.sMaxAgeSeconds = i2;
+        this.isPrivate = z3;
+        this.isPublic = z4;
+        this.mustRevalidate = z5;
+        this.maxStaleSeconds = i3;
+        this.minFreshSeconds = i4;
+        this.onlyIfCached = z6;
+        this.noTransform = z7;
+        this.immutable = z8;
+        this.headerValue = str;
+    }
+
+    public CacheControl(Builder builder) {
+        this.noCache = builder.noCache;
+        this.noStore = builder.noStore;
+        this.maxAgeSeconds = builder.maxAgeSeconds;
+        this.sMaxAgeSeconds = -1;
+        this.isPrivate = false;
+        this.isPublic = false;
+        this.mustRevalidate = false;
+        this.maxStaleSeconds = builder.maxStaleSeconds;
+        this.minFreshSeconds = builder.minFreshSeconds;
+        this.onlyIfCached = builder.onlyIfCached;
+        this.noTransform = builder.noTransform;
+        this.immutable = builder.immutable;
+    }
+
+    /* JADX WARN: Removed duplicated region for block: B:10:0x0042  */
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    public static com.mbridge.msdk.thrid.okhttp.CacheControl parse(com.mbridge.msdk.thrid.okhttp.Headers r22) {
+        /*
+            Method dump skipped, instructions count: 341
+            To view this dump add '--comments-level debug' option
+        */
+        throw new UnsupportedOperationException("Method not decompiled: com.mbridge.msdk.thrid.okhttp.CacheControl.parse(com.mbridge.msdk.thrid.okhttp.Headers):com.mbridge.msdk.thrid.okhttp.CacheControl");
+    }
+
+    public String toString() {
+        String str = this.headerValue;
+        if (str != null) {
+            return str;
+        }
+        String headerValue = headerValue();
+        this.headerValue = headerValue;
+        return headerValue;
+    }
+
+    private String headerValue() {
+        StringBuilder sb = new StringBuilder();
+        if (this.noCache) {
+            sb.append("no-cache, ");
+        }
+        if (this.noStore) {
+            sb.append("no-store, ");
+        }
+        if (this.maxAgeSeconds != -1) {
+            sb.append("max-age=");
+            sb.append(this.maxAgeSeconds);
+            sb.append(", ");
+        }
+        if (this.sMaxAgeSeconds != -1) {
+            sb.append("s-maxage=");
+            sb.append(this.sMaxAgeSeconds);
+            sb.append(", ");
+        }
+        if (this.isPrivate) {
+            sb.append("private, ");
+        }
+        if (this.isPublic) {
+            sb.append("public, ");
+        }
+        if (this.mustRevalidate) {
+            sb.append("must-revalidate, ");
+        }
+        if (this.maxStaleSeconds != -1) {
+            sb.append("max-stale=");
+            sb.append(this.maxStaleSeconds);
+            sb.append(", ");
+        }
+        if (this.minFreshSeconds != -1) {
+            sb.append("min-fresh=");
+            sb.append(this.minFreshSeconds);
+            sb.append(", ");
+        }
+        if (this.onlyIfCached) {
+            sb.append("only-if-cached, ");
+        }
+        if (this.noTransform) {
+            sb.append("no-transform, ");
+        }
+        if (this.immutable) {
+            sb.append("immutable, ");
+        }
+        if (sb.length() == 0) {
+            return "";
+        }
+        sb.delete(sb.length() - 2, sb.length());
+        return sb.toString();
+    }
+
+    public static final class Builder {
+        boolean immutable;
+        int maxAgeSeconds = -1;
+        int maxStaleSeconds = -1;
+        int minFreshSeconds = -1;
+        boolean noCache;
+        boolean noStore;
+        boolean noTransform;
+        boolean onlyIfCached;
+
+        public Builder immutable() {
+            this.immutable = true;
+            return this;
+        }
+
+        public Builder noCache() {
+            this.noCache = true;
+            return this;
+        }
+
+        public Builder noStore() {
+            this.noStore = true;
+            return this;
+        }
+
+        public Builder noTransform() {
+            this.noTransform = true;
+            return this;
+        }
+
+        public Builder onlyIfCached() {
+            this.onlyIfCached = true;
+            return this;
+        }
+
+        public Builder maxAge(int i, TimeUnit timeUnit) {
+            if (i < 0) {
+                throw new IllegalArgumentException("maxAge < 0: " + i);
+            }
+            long seconds = timeUnit.toSeconds(i);
+            this.maxAgeSeconds = seconds > 2147483647L ? Integer.MAX_VALUE : (int) seconds;
+            return this;
+        }
+
+        public Builder maxStale(int i, TimeUnit timeUnit) {
+            if (i < 0) {
+                throw new IllegalArgumentException("maxStale < 0: " + i);
+            }
+            long seconds = timeUnit.toSeconds(i);
+            this.maxStaleSeconds = seconds > 2147483647L ? Integer.MAX_VALUE : (int) seconds;
+            return this;
+        }
+
+        public Builder minFresh(int i, TimeUnit timeUnit) {
+            if (i < 0) {
+                throw new IllegalArgumentException("minFresh < 0: " + i);
+            }
+            long seconds = timeUnit.toSeconds(i);
+            this.minFreshSeconds = seconds > 2147483647L ? Integer.MAX_VALUE : (int) seconds;
+            return this;
+        }
+
+        public CacheControl build() {
+            return new CacheControl(this);
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/thrid/okhttp/Call.java

@@ -0,0 +1,28 @@
+package com.mbridge.msdk.thrid.okhttp;
+
+import com.mbridge.msdk.thrid.okio.Timeout;
+import java.io.IOException;
+
+/* loaded from: classes4.dex */
+public interface Call extends Cloneable {
+
+    public interface Factory {
+        Call newCall(Request request);
+    }
+
+    void cancel();
+
+    Call clone();
+
+    void enqueue(Callback callback);
+
+    Response execute() throws IOException;
+
+    boolean isCanceled();
+
+    boolean isExecuted();
+
+    Request request();
+
+    Timeout timeout();
+}

decompiled/sources/com/mbridge/msdk/thrid/okhttp/Callback.java

@@ -0,0 +1,10 @@
+package com.mbridge.msdk.thrid.okhttp;
+
+import java.io.IOException;
+
+/* loaded from: classes4.dex */
+public interface Callback {
+    void onFailure(Call call, IOException iOException);
+
+    void onResponse(Call call, Response response) throws IOException;
+}

decompiled/sources/com/mbridge/msdk/thrid/okhttp/CertificatePinner.java

@@ -0,0 +1,223 @@
+package com.mbridge.msdk.thrid.okhttp;
+
+import com.facebook.internal.security.CertificateUtil;
+import com.ironsource.mediationsdk.logger.IronSourceError;
+import com.mbridge.msdk.thrid.okhttp.internal.Util;
+import com.mbridge.msdk.thrid.okhttp.internal.tls.CertificateChainCleaner;
+import com.mbridge.msdk.thrid.okio.ByteString;
+import java.security.cert.Certificate;
+import java.security.cert.X509Certificate;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Set;
+import javax.net.ssl.SSLPeerUnverifiedException;
+
+/* loaded from: classes4.dex */
+public final class CertificatePinner {
+    public static final CertificatePinner DEFAULT = new Builder().build();
+    private final CertificateChainCleaner certificateChainCleaner;
+    private final Set<Pin> pins;
+
+    public CertificatePinner(Set<Pin> set, CertificateChainCleaner certificateChainCleaner) {
+        this.pins = set;
+        this.certificateChainCleaner = certificateChainCleaner;
+    }
+
+    public boolean equals(Object obj) {
+        if (obj == this) {
+            return true;
+        }
+        if (obj instanceof CertificatePinner) {
+            CertificatePinner certificatePinner = (CertificatePinner) obj;
+            if (Util.equal(this.certificateChainCleaner, certificatePinner.certificateChainCleaner) && this.pins.equals(certificatePinner.pins)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public int hashCode() {
+        CertificateChainCleaner certificateChainCleaner = this.certificateChainCleaner;
+        return ((certificateChainCleaner != null ? certificateChainCleaner.hashCode() : 0) * 31) + this.pins.hashCode();
+    }
+
+    public void check(String str, List<Certificate> list) throws SSLPeerUnverifiedException {
+        List<Pin> findMatchingPins = findMatchingPins(str);
+        if (findMatchingPins.isEmpty()) {
+            return;
+        }
+        CertificateChainCleaner certificateChainCleaner = this.certificateChainCleaner;
+        if (certificateChainCleaner != null) {
+            list = certificateChainCleaner.clean(list, str);
+        }
+        int size = list.size();
+        for (int i = 0; i < size; i++) {
+            X509Certificate x509Certificate = (X509Certificate) list.get(i);
+            int size2 = findMatchingPins.size();
+            ByteString byteString = null;
+            ByteString byteString2 = null;
+            for (int i2 = 0; i2 < size2; i2++) {
+                Pin pin = findMatchingPins.get(i2);
+                if (pin.hashAlgorithm.equals("sha256/")) {
+                    if (byteString == null) {
+                        byteString = sha256(x509Certificate);
+                    }
+                    if (pin.hash.equals(byteString)) {
+                        return;
+                    }
+                } else if (pin.hashAlgorithm.equals("sha1/")) {
+                    if (byteString2 == null) {
+                        byteString2 = sha1(x509Certificate);
+                    }
+                    if (pin.hash.equals(byteString2)) {
+                        return;
+                    }
+                } else {
+                    throw new AssertionError("unsupported hashAlgorithm: " + pin.hashAlgorithm);
+                }
+            }
+        }
+        StringBuilder sb = new StringBuilder();
+        sb.append("Certificate pinning failure!");
+        sb.append("\n  Peer certificate chain:");
+        int size3 = list.size();
+        for (int i3 = 0; i3 < size3; i3++) {
+            X509Certificate x509Certificate2 = (X509Certificate) list.get(i3);
+            sb.append("\n    ");
+            sb.append(pin(x509Certificate2));
+            sb.append(": ");
+            sb.append(x509Certificate2.getSubjectDN().getName());
+        }
+        sb.append("\n  Pinned certificates for ");
+        sb.append(str);
+        sb.append(CertificateUtil.DELIMITER);
+        int size4 = findMatchingPins.size();
+        for (int i4 = 0; i4 < size4; i4++) {
+            Pin pin2 = findMatchingPins.get(i4);
+            sb.append("\n    ");
+            sb.append(pin2);
+        }
+        throw new SSLPeerUnverifiedException(sb.toString());
+    }
+
+    public void check(String str, Certificate... certificateArr) throws SSLPeerUnverifiedException {
+        check(str, Arrays.asList(certificateArr));
+    }
+
+    public List<Pin> findMatchingPins(String str) {
+        List<Pin> emptyList = Collections.emptyList();
+        for (Pin pin : this.pins) {
+            if (pin.matches(str)) {
+                if (emptyList.isEmpty()) {
+                    emptyList = new ArrayList<>();
+                }
+                emptyList.add(pin);
+            }
+        }
+        return emptyList;
+    }
+
+    public CertificatePinner withCertificateChainCleaner(CertificateChainCleaner certificateChainCleaner) {
+        return Util.equal(this.certificateChainCleaner, certificateChainCleaner) ? this : new CertificatePinner(this.pins, certificateChainCleaner);
+    }
+
+    public static String pin(Certificate certificate) {
+        if (!(certificate instanceof X509Certificate)) {
+            throw new IllegalArgumentException("Certificate pinning requires X509 certificates");
+        }
+        return "sha256/" + sha256((X509Certificate) certificate).base64();
+    }
+
+    public static ByteString sha1(X509Certificate x509Certificate) {
+        return ByteString.of(x509Certificate.getPublicKey().getEncoded()).sha1();
+    }
+
+    public static ByteString sha256(X509Certificate x509Certificate) {
+        return ByteString.of(x509Certificate.getPublicKey().getEncoded()).sha256();
+    }
+
+    public static final class Pin {
+        private static final String WILDCARD = "*.";
+        final String canonicalHostname;
+        final ByteString hash;
+        final String hashAlgorithm;
+        final String pattern;
+
+        public Pin(String str, String str2) {
+            String host;
+            this.pattern = str;
+            if (str.startsWith(WILDCARD)) {
+                host = HttpUrl.get("http://" + str.substring(2)).host();
+            } else {
+                host = HttpUrl.get("http://" + str).host();
+            }
+            this.canonicalHostname = host;
+            if (str2.startsWith("sha1/")) {
+                this.hashAlgorithm = "sha1/";
+                this.hash = ByteString.decodeBase64(str2.substring(5));
+            } else if (str2.startsWith("sha256/")) {
+                this.hashAlgorithm = "sha256/";
+                this.hash = ByteString.decodeBase64(str2.substring(7));
+            } else {
+                throw new IllegalArgumentException("pins must start with 'sha256/' or 'sha1/': " + str2);
+            }
+            if (this.hash != null) {
+                return;
+            }
+            throw new IllegalArgumentException("pins must be base64: " + str2);
+        }
+
+        public boolean matches(String str) {
+            if (this.pattern.startsWith(WILDCARD)) {
+                int indexOf = str.indexOf(46);
+                if ((str.length() - indexOf) - 1 == this.canonicalHostname.length()) {
+                    String str2 = this.canonicalHostname;
+                    if (str.regionMatches(false, indexOf + 1, str2, 0, str2.length())) {
+                        return true;
+                    }
+                }
+                return false;
+            }
+            return str.equals(this.canonicalHostname);
+        }
+
+        public boolean equals(Object obj) {
+            if (obj instanceof Pin) {
+                Pin pin = (Pin) obj;
+                if (this.pattern.equals(pin.pattern) && this.hashAlgorithm.equals(pin.hashAlgorithm) && this.hash.equals(pin.hash)) {
+                    return true;
+                }
+            }
+            return false;
+        }
+
+        public int hashCode() {
+            return ((((IronSourceError.ERROR_NON_EXISTENT_INSTANCE + this.pattern.hashCode()) * 31) + this.hashAlgorithm.hashCode()) * 31) + this.hash.hashCode();
+        }
+
+        public String toString() {
+            return this.hashAlgorithm + this.hash.base64();
+        }
+    }
+
+    public static final class Builder {
+        private final List<Pin> pins = new ArrayList();
+
+        public Builder add(String str, String... strArr) {
+            if (str == null) {
+                throw new NullPointerException("pattern == null");
+            }
+            for (String str2 : strArr) {
+                this.pins.add(new Pin(str, str2));
+            }
+            return this;
+        }
+
+        public CertificatePinner build() {
+            return new CertificatePinner(new LinkedHashSet(this.pins), null);
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/thrid/okhttp/Challenge.java

@@ -0,0 +1,91 @@
+package com.mbridge.msdk.thrid.okhttp;
+
+import com.ironsource.nb;
+import com.mbridge.msdk.thrid.okhttp.internal.Util;
+import java.nio.charset.Charset;
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.Locale;
+import java.util.Map;
+
+/* loaded from: classes4.dex */
+public final class Challenge {
+    private final Map<String, String> authParams;
+    private final String scheme;
+
+    public Map<String, String> authParams() {
+        return this.authParams;
+    }
+
+    public String scheme() {
+        return this.scheme;
+    }
+
+    public Challenge(String str, Map<String, String> map) {
+        if (str == null) {
+            throw new NullPointerException("scheme == null");
+        }
+        if (map == null) {
+            throw new NullPointerException("authParams == null");
+        }
+        this.scheme = str;
+        LinkedHashMap linkedHashMap = new LinkedHashMap();
+        for (Map.Entry<String, String> entry : map.entrySet()) {
+            linkedHashMap.put(entry.getKey() == null ? null : entry.getKey().toLowerCase(Locale.US), entry.getValue());
+        }
+        this.authParams = Collections.unmodifiableMap(linkedHashMap);
+    }
+
+    public Challenge(String str, String str2) {
+        if (str == null) {
+            throw new NullPointerException("scheme == null");
+        }
+        if (str2 == null) {
+            throw new NullPointerException("realm == null");
+        }
+        this.scheme = str;
+        this.authParams = Collections.singletonMap("realm", str2);
+    }
+
+    public Challenge withCharset(Charset charset) {
+        if (charset == null) {
+            throw new NullPointerException("charset == null");
+        }
+        LinkedHashMap linkedHashMap = new LinkedHashMap(this.authParams);
+        linkedHashMap.put(nb.M, charset.name());
+        return new Challenge(this.scheme, linkedHashMap);
+    }
+
+    public String realm() {
+        return this.authParams.get("realm");
+    }
+
+    public Charset charset() {
+        String str = this.authParams.get(nb.M);
+        if (str != null) {
+            try {
+                return Charset.forName(str);
+            } catch (Exception unused) {
+            }
+        }
+        return Util.ISO_8859_1;
+    }
+
+    public boolean equals(Object obj) {
+        if (obj instanceof Challenge) {
+            Challenge challenge = (Challenge) obj;
+            if (challenge.scheme.equals(this.scheme) && challenge.authParams.equals(this.authParams)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public int hashCode() {
+        return ((899 + this.scheme.hashCode()) * 31) + this.authParams.hashCode();
+    }
+
+    public String toString() {
+        return this.scheme + " authParams=" + this.authParams;
+    }
+}

decompiled/sources/com/mbridge/msdk/thrid/okhttp/CipherSuite.java

@@ -0,0 +1,211 @@
+package com.mbridge.msdk.thrid.okhttp;
+
+import com.ironsource.mediationsdk.utils.IronSourceConstants;
+import com.vungle.ads.internal.signals.SignalKey;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+/* loaded from: classes4.dex */
+public final class CipherSuite {
+    final String javaName;
+    static final Comparator<String> ORDER_BY_NAME = new Comparator<String>() { // from class: com.mbridge.msdk.thrid.okhttp.CipherSuite.1
+        @Override // java.util.Comparator
+        public int compare(String str, String str2) {
+            int min = Math.min(str.length(), str2.length());
+            for (int i = 4; i < min; i++) {
+                char charAt = str.charAt(i);
+                char charAt2 = str2.charAt(i);
+                if (charAt != charAt2) {
+                    return charAt < charAt2 ? -1 : 1;
+                }
+            }
+            int length = str.length();
+            int length2 = str2.length();
+            if (length != length2) {
+                return length < length2 ? -1 : 1;
+            }
+            return 0;
+        }
+    };
+    private static final Map<String, CipherSuite> INSTANCES = new LinkedHashMap();
+    public static final CipherSuite TLS_RSA_WITH_NULL_MD5 = init("SSL_RSA_WITH_NULL_MD5", 1);
+    public static final CipherSuite TLS_RSA_WITH_NULL_SHA = init("SSL_RSA_WITH_NULL_SHA", 2);
+    public static final CipherSuite TLS_RSA_EXPORT_WITH_RC4_40_MD5 = init("SSL_RSA_EXPORT_WITH_RC4_40_MD5", 3);
+    public static final CipherSuite TLS_RSA_WITH_RC4_128_MD5 = init("SSL_RSA_WITH_RC4_128_MD5", 4);
+    public static final CipherSuite TLS_RSA_WITH_RC4_128_SHA = init("SSL_RSA_WITH_RC4_128_SHA", 5);
+    public static final CipherSuite TLS_RSA_EXPORT_WITH_DES40_CBC_SHA = init("SSL_RSA_EXPORT_WITH_DES40_CBC_SHA", 8);
+    public static final CipherSuite TLS_RSA_WITH_DES_CBC_SHA = init("SSL_RSA_WITH_DES_CBC_SHA", 9);
+    public static final CipherSuite TLS_RSA_WITH_3DES_EDE_CBC_SHA = init("SSL_RSA_WITH_3DES_EDE_CBC_SHA", 10);
+    public static final CipherSuite TLS_DHE_DSS_EXPORT_WITH_DES40_CBC_SHA = init("SSL_DHE_DSS_EXPORT_WITH_DES40_CBC_SHA", 17);
+    public static final CipherSuite TLS_DHE_DSS_WITH_DES_CBC_SHA = init("SSL_DHE_DSS_WITH_DES_CBC_SHA", 18);
+    public static final CipherSuite TLS_DHE_DSS_WITH_3DES_EDE_CBC_SHA = init("SSL_DHE_DSS_WITH_3DES_EDE_CBC_SHA", 19);
+    public static final CipherSuite TLS_DHE_RSA_EXPORT_WITH_DES40_CBC_SHA = init("SSL_DHE_RSA_EXPORT_WITH_DES40_CBC_SHA", 20);
+    public static final CipherSuite TLS_DHE_RSA_WITH_DES_CBC_SHA = init("SSL_DHE_RSA_WITH_DES_CBC_SHA", 21);
+    public static final CipherSuite TLS_DHE_RSA_WITH_3DES_EDE_CBC_SHA = init("SSL_DHE_RSA_WITH_3DES_EDE_CBC_SHA", 22);
+    public static final CipherSuite TLS_DH_anon_EXPORT_WITH_RC4_40_MD5 = init("SSL_DH_anon_EXPORT_WITH_RC4_40_MD5", 23);
+    public static final CipherSuite TLS_DH_anon_WITH_RC4_128_MD5 = init("SSL_DH_anon_WITH_RC4_128_MD5", 24);
+    public static final CipherSuite TLS_DH_anon_EXPORT_WITH_DES40_CBC_SHA = init("SSL_DH_anon_EXPORT_WITH_DES40_CBC_SHA", 25);
+    public static final CipherSuite TLS_DH_anon_WITH_DES_CBC_SHA = init("SSL_DH_anon_WITH_DES_CBC_SHA", 26);
+    public static final CipherSuite TLS_DH_anon_WITH_3DES_EDE_CBC_SHA = init("SSL_DH_anon_WITH_3DES_EDE_CBC_SHA", 27);
+    public static final CipherSuite TLS_KRB5_WITH_DES_CBC_SHA = init("TLS_KRB5_WITH_DES_CBC_SHA", 30);
+    public static final CipherSuite TLS_KRB5_WITH_3DES_EDE_CBC_SHA = init("TLS_KRB5_WITH_3DES_EDE_CBC_SHA", 31);
+    public static final CipherSuite TLS_KRB5_WITH_RC4_128_SHA = init("TLS_KRB5_WITH_RC4_128_SHA", 32);
+    public static final CipherSuite TLS_KRB5_WITH_DES_CBC_MD5 = init("TLS_KRB5_WITH_DES_CBC_MD5", 34);
+    public static final CipherSuite TLS_KRB5_WITH_3DES_EDE_CBC_MD5 = init("TLS_KRB5_WITH_3DES_EDE_CBC_MD5", 35);
+    public static final CipherSuite TLS_KRB5_WITH_RC4_128_MD5 = init("TLS_KRB5_WITH_RC4_128_MD5", 36);
+    public static final CipherSuite TLS_KRB5_EXPORT_WITH_DES_CBC_40_SHA = init("TLS_KRB5_EXPORT_WITH_DES_CBC_40_SHA", 38);
+    public static final CipherSuite TLS_KRB5_EXPORT_WITH_RC4_40_SHA = init("TLS_KRB5_EXPORT_WITH_RC4_40_SHA", 40);
+    public static final CipherSuite TLS_KRB5_EXPORT_WITH_DES_CBC_40_MD5 = init("TLS_KRB5_EXPORT_WITH_DES_CBC_40_MD5", 41);
+    public static final CipherSuite TLS_KRB5_EXPORT_WITH_RC4_40_MD5 = init("TLS_KRB5_EXPORT_WITH_RC4_40_MD5", 43);
+    public static final CipherSuite TLS_RSA_WITH_AES_128_CBC_SHA = init("TLS_RSA_WITH_AES_128_CBC_SHA", 47);
+    public static final CipherSuite TLS_DHE_DSS_WITH_AES_128_CBC_SHA = init("TLS_DHE_DSS_WITH_AES_128_CBC_SHA", 50);
+    public static final CipherSuite TLS_DHE_RSA_WITH_AES_128_CBC_SHA = init("TLS_DHE_RSA_WITH_AES_128_CBC_SHA", 51);
+    public static final CipherSuite TLS_DH_anon_WITH_AES_128_CBC_SHA = init("TLS_DH_anon_WITH_AES_128_CBC_SHA", 52);
+    public static final CipherSuite TLS_RSA_WITH_AES_256_CBC_SHA = init("TLS_RSA_WITH_AES_256_CBC_SHA", 53);
+    public static final CipherSuite TLS_DHE_DSS_WITH_AES_256_CBC_SHA = init("TLS_DHE_DSS_WITH_AES_256_CBC_SHA", 56);
+    public static final CipherSuite TLS_DHE_RSA_WITH_AES_256_CBC_SHA = init("TLS_DHE_RSA_WITH_AES_256_CBC_SHA", 57);
+    public static final CipherSuite TLS_DH_anon_WITH_AES_256_CBC_SHA = init("TLS_DH_anon_WITH_AES_256_CBC_SHA", 58);
+    public static final CipherSuite TLS_RSA_WITH_NULL_SHA256 = init("TLS_RSA_WITH_NULL_SHA256", 59);
+    public static final CipherSuite TLS_RSA_WITH_AES_128_CBC_SHA256 = init("TLS_RSA_WITH_AES_128_CBC_SHA256", 60);
+    public static final CipherSuite TLS_RSA_WITH_AES_256_CBC_SHA256 = init("TLS_RSA_WITH_AES_256_CBC_SHA256", 61);
+    public static final CipherSuite TLS_DHE_DSS_WITH_AES_128_CBC_SHA256 = init("TLS_DHE_DSS_WITH_AES_128_CBC_SHA256", 64);
+    public static final CipherSuite TLS_RSA_WITH_CAMELLIA_128_CBC_SHA = init("TLS_RSA_WITH_CAMELLIA_128_CBC_SHA", 65);
+    public static final CipherSuite TLS_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA = init("TLS_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA", 68);
+    public static final CipherSuite TLS_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA = init("TLS_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA", 69);
+    public static final CipherSuite TLS_DHE_RSA_WITH_AES_128_CBC_SHA256 = init("TLS_DHE_RSA_WITH_AES_128_CBC_SHA256", 103);
+    public static final CipherSuite TLS_DHE_DSS_WITH_AES_256_CBC_SHA256 = init("TLS_DHE_DSS_WITH_AES_256_CBC_SHA256", 106);
+    public static final CipherSuite TLS_DHE_RSA_WITH_AES_256_CBC_SHA256 = init("TLS_DHE_RSA_WITH_AES_256_CBC_SHA256", SignalKey.EVENT_ID);
+    public static final CipherSuite TLS_DH_anon_WITH_AES_128_CBC_SHA256 = init("TLS_DH_anon_WITH_AES_128_CBC_SHA256", 108);
+    public static final CipherSuite TLS_DH_anon_WITH_AES_256_CBC_SHA256 = init("TLS_DH_anon_WITH_AES_256_CBC_SHA256", 109);
+    public static final CipherSuite TLS_RSA_WITH_CAMELLIA_256_CBC_SHA = init("TLS_RSA_WITH_CAMELLIA_256_CBC_SHA", 132);
+    public static final CipherSuite TLS_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA = init("TLS_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA", 135);
+    public static final CipherSuite TLS_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA = init("TLS_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA", 136);
+    public static final CipherSuite TLS_PSK_WITH_RC4_128_SHA = init("TLS_PSK_WITH_RC4_128_SHA", 138);
+    public static final CipherSuite TLS_PSK_WITH_3DES_EDE_CBC_SHA = init("TLS_PSK_WITH_3DES_EDE_CBC_SHA", 139);
+    public static final CipherSuite TLS_PSK_WITH_AES_128_CBC_SHA = init("TLS_PSK_WITH_AES_128_CBC_SHA", IronSourceConstants.USING_CACHE_FOR_INIT_EVENT);
+    public static final CipherSuite TLS_PSK_WITH_AES_256_CBC_SHA = init("TLS_PSK_WITH_AES_256_CBC_SHA", 141);
+    public static final CipherSuite TLS_RSA_WITH_SEED_CBC_SHA = init("TLS_RSA_WITH_SEED_CBC_SHA", IronSourceConstants.REWARDED_VIDEO_DAILY_CAPPED);
+    public static final CipherSuite TLS_RSA_WITH_AES_128_GCM_SHA256 = init("TLS_RSA_WITH_AES_128_GCM_SHA256", 156);
+    public static final CipherSuite TLS_RSA_WITH_AES_256_GCM_SHA384 = init("TLS_RSA_WITH_AES_256_GCM_SHA384", 157);
+    public static final CipherSuite TLS_DHE_RSA_WITH_AES_128_GCM_SHA256 = init("TLS_DHE_RSA_WITH_AES_128_GCM_SHA256", 158);
+    public static final CipherSuite TLS_DHE_RSA_WITH_AES_256_GCM_SHA384 = init("TLS_DHE_RSA_WITH_AES_256_GCM_SHA384", 159);
+    public static final CipherSuite TLS_DHE_DSS_WITH_AES_128_GCM_SHA256 = init("TLS_DHE_DSS_WITH_AES_128_GCM_SHA256", 162);
+    public static final CipherSuite TLS_DHE_DSS_WITH_AES_256_GCM_SHA384 = init("TLS_DHE_DSS_WITH_AES_256_GCM_SHA384", 163);
+    public static final CipherSuite TLS_DH_anon_WITH_AES_128_GCM_SHA256 = init("TLS_DH_anon_WITH_AES_128_GCM_SHA256", 166);
+    public static final CipherSuite TLS_DH_anon_WITH_AES_256_GCM_SHA384 = init("TLS_DH_anon_WITH_AES_256_GCM_SHA384", 167);
+    public static final CipherSuite TLS_EMPTY_RENEGOTIATION_INFO_SCSV = init("TLS_EMPTY_RENEGOTIATION_INFO_SCSV", 255);
+    public static final CipherSuite TLS_FALLBACK_SCSV = init("TLS_FALLBACK_SCSV", 22016);
+    public static final CipherSuite TLS_ECDH_ECDSA_WITH_NULL_SHA = init("TLS_ECDH_ECDSA_WITH_NULL_SHA", 49153);
+    public static final CipherSuite TLS_ECDH_ECDSA_WITH_RC4_128_SHA = init("TLS_ECDH_ECDSA_WITH_RC4_128_SHA", 49154);
+    public static final CipherSuite TLS_ECDH_ECDSA_WITH_3DES_EDE_CBC_SHA = init("TLS_ECDH_ECDSA_WITH_3DES_EDE_CBC_SHA", 49155);
+    public static final CipherSuite TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA = init("TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA", 49156);
+    public static final CipherSuite TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA = init("TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA", 49157);
+    public static final CipherSuite TLS_ECDHE_ECDSA_WITH_NULL_SHA = init("TLS_ECDHE_ECDSA_WITH_NULL_SHA", 49158);
+    public static final CipherSuite TLS_ECDHE_ECDSA_WITH_RC4_128_SHA = init("TLS_ECDHE_ECDSA_WITH_RC4_128_SHA", 49159);
+    public static final CipherSuite TLS_ECDHE_ECDSA_WITH_3DES_EDE_CBC_SHA = init("TLS_ECDHE_ECDSA_WITH_3DES_EDE_CBC_SHA", 49160);
+    public static final CipherSuite TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA = init("TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA", 49161);
+    public static final CipherSuite TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA = init("TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA", 49162);
+    public static final CipherSuite TLS_ECDH_RSA_WITH_NULL_SHA = init("TLS_ECDH_RSA_WITH_NULL_SHA", 49163);
+    public static final CipherSuite TLS_ECDH_RSA_WITH_RC4_128_SHA = init("TLS_ECDH_RSA_WITH_RC4_128_SHA", 49164);
+    public static final CipherSuite TLS_ECDH_RSA_WITH_3DES_EDE_CBC_SHA = init("TLS_ECDH_RSA_WITH_3DES_EDE_CBC_SHA", 49165);
+    public static final CipherSuite TLS_ECDH_RSA_WITH_AES_128_CBC_SHA = init("TLS_ECDH_RSA_WITH_AES_128_CBC_SHA", 49166);
+    public static final CipherSuite TLS_ECDH_RSA_WITH_AES_256_CBC_SHA = init("TLS_ECDH_RSA_WITH_AES_256_CBC_SHA", 49167);
+    public static final CipherSuite TLS_ECDHE_RSA_WITH_NULL_SHA = init("TLS_ECDHE_RSA_WITH_NULL_SHA", 49168);
+    public static final CipherSuite TLS_ECDHE_RSA_WITH_RC4_128_SHA = init("TLS_ECDHE_RSA_WITH_RC4_128_SHA", 49169);
+    public static final CipherSuite TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA = init("TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA", 49170);
+    public static final CipherSuite TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA = init("TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA", 49171);
+    public static final CipherSuite TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA = init("TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA", 49172);
+    public static final CipherSuite TLS_ECDH_anon_WITH_NULL_SHA = init("TLS_ECDH_anon_WITH_NULL_SHA", 49173);
+    public static final CipherSuite TLS_ECDH_anon_WITH_RC4_128_SHA = init("TLS_ECDH_anon_WITH_RC4_128_SHA", 49174);
+    public static final CipherSuite TLS_ECDH_anon_WITH_3DES_EDE_CBC_SHA = init("TLS_ECDH_anon_WITH_3DES_EDE_CBC_SHA", 49175);
+    public static final CipherSuite TLS_ECDH_anon_WITH_AES_128_CBC_SHA = init("TLS_ECDH_anon_WITH_AES_128_CBC_SHA", 49176);
+    public static final CipherSuite TLS_ECDH_anon_WITH_AES_256_CBC_SHA = init("TLS_ECDH_anon_WITH_AES_256_CBC_SHA", 49177);
+    public static final CipherSuite TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256 = init("TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256", 49187);
+    public static final CipherSuite TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384 = init("TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384", 49188);
+    public static final CipherSuite TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA256 = init("TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA256", 49189);
+    public static final CipherSuite TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA384 = init("TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA384", 49190);
+    public static final CipherSuite TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256 = init("TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256", 49191);
+    public static final CipherSuite TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384 = init("TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384", 49192);
+    public static final CipherSuite TLS_ECDH_RSA_WITH_AES_128_CBC_SHA256 = init("TLS_ECDH_RSA_WITH_AES_128_CBC_SHA256", 49193);
+    public static final CipherSuite TLS_ECDH_RSA_WITH_AES_256_CBC_SHA384 = init("TLS_ECDH_RSA_WITH_AES_256_CBC_SHA384", 49194);
+    public static final CipherSuite TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256 = init("TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256", 49195);
+    public static final CipherSuite TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384 = init("TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384", 49196);
+    public static final CipherSuite TLS_ECDH_ECDSA_WITH_AES_128_GCM_SHA256 = init("TLS_ECDH_ECDSA_WITH_AES_128_GCM_SHA256", 49197);
+    public static final CipherSuite TLS_ECDH_ECDSA_WITH_AES_256_GCM_SHA384 = init("TLS_ECDH_ECDSA_WITH_AES_256_GCM_SHA384", 49198);
+    public static final CipherSuite TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256 = init("TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256", 49199);
+    public static final CipherSuite TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 = init("TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384", 49200);
+    public static final CipherSuite TLS_ECDH_RSA_WITH_AES_128_GCM_SHA256 = init("TLS_ECDH_RSA_WITH_AES_128_GCM_SHA256", 49201);
+    public static final CipherSuite TLS_ECDH_RSA_WITH_AES_256_GCM_SHA384 = init("TLS_ECDH_RSA_WITH_AES_256_GCM_SHA384", 49202);
+    public static final CipherSuite TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA = init("TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA", 49205);
+    public static final CipherSuite TLS_ECDHE_PSK_WITH_AES_256_CBC_SHA = init("TLS_ECDHE_PSK_WITH_AES_256_CBC_SHA", 49206);
+    public static final CipherSuite TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256 = init("TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256", 52392);
+    public static final CipherSuite TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256 = init("TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256", 52393);
+    public static final CipherSuite TLS_DHE_RSA_WITH_CHACHA20_POLY1305_SHA256 = init("TLS_DHE_RSA_WITH_CHACHA20_POLY1305_SHA256", 52394);
+    public static final CipherSuite TLS_ECDHE_PSK_WITH_CHACHA20_POLY1305_SHA256 = init("TLS_ECDHE_PSK_WITH_CHACHA20_POLY1305_SHA256", 52396);
+    public static final CipherSuite TLS_AES_128_GCM_SHA256 = init("TLS_AES_128_GCM_SHA256", 4865);
+    public static final CipherSuite TLS_AES_256_GCM_SHA384 = init("TLS_AES_256_GCM_SHA384", 4866);
+    public static final CipherSuite TLS_CHACHA20_POLY1305_SHA256 = init("TLS_CHACHA20_POLY1305_SHA256", 4867);
+    public static final CipherSuite TLS_AES_128_CCM_SHA256 = init("TLS_AES_128_CCM_SHA256", 4868);
+    public static final CipherSuite TLS_AES_256_CCM_8_SHA256 = init("TLS_AES_256_CCM_8_SHA256", 4869);
+
+    public String javaName() {
+        return this.javaName;
+    }
+
+    public String toString() {
+        return this.javaName;
+    }
+
+    public static synchronized CipherSuite forJavaName(String str) {
+        CipherSuite cipherSuite;
+        synchronized (CipherSuite.class) {
+            try {
+                Map<String, CipherSuite> map = INSTANCES;
+                cipherSuite = map.get(str);
+                if (cipherSuite == null) {
+                    cipherSuite = map.get(secondaryName(str));
+                    if (cipherSuite == null) {
+                        cipherSuite = new CipherSuite(str);
+                    }
+                    map.put(str, cipherSuite);
+                }
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+        return cipherSuite;
+    }
+
+    private static String secondaryName(String str) {
+        if (str.startsWith("TLS_")) {
+            return "SSL_" + str.substring(4);
+        }
+        if (!str.startsWith("SSL_")) {
+            return str;
+        }
+        return "TLS_" + str.substring(4);
+    }
+
+    public static List<CipherSuite> forJavaNames(String... strArr) {
+        ArrayList arrayList = new ArrayList(strArr.length);
+        for (String str : strArr) {
+            arrayList.add(forJavaName(str));
+        }
+        return Collections.unmodifiableList(arrayList);
+    }
+
+    private CipherSuite(String str) {
+        str.getClass();
+        this.javaName = str;
+    }
+
+    private static CipherSuite init(String str, int i) {
+        CipherSuite cipherSuite = new CipherSuite(str);
+        INSTANCES.put(str, cipherSuite);
+        return cipherSuite;
+    }
+}

decompiled/sources/com/mbridge/msdk/thrid/okhttp/Connection.java

@@ -0,0 +1,14 @@
+package com.mbridge.msdk.thrid.okhttp;
+
+import java.net.Socket;
+
+/* loaded from: classes4.dex */
+public interface Connection {
+    Handshake handshake();
+
+    Protocol protocol();
+
+    Route route();
+
+    Socket socket();
+}

decompiled/sources/com/mbridge/msdk/thrid/okhttp/ConnectionPool.java

@@ -0,0 +1,200 @@
+package com.mbridge.msdk.thrid.okhttp;
+
+import com.mbridge.msdk.thrid.okhttp.internal.Util;
+import com.mbridge.msdk.thrid.okhttp.internal.connection.RealConnection;
+import com.mbridge.msdk.thrid.okhttp.internal.connection.RouteDatabase;
+import com.mbridge.msdk.thrid.okhttp.internal.connection.StreamAllocation;
+import com.mbridge.msdk.thrid.okhttp.internal.platform.Platform;
+import java.lang.ref.Reference;
+import java.net.Socket;
+import java.util.ArrayDeque;
+import java.util.ArrayList;
+import java.util.Deque;
+import java.util.Iterator;
+import java.util.List;
+import java.util.concurrent.Executor;
+import java.util.concurrent.SynchronousQueue;
+import java.util.concurrent.ThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;
+
+/* loaded from: classes4.dex */
+public final class ConnectionPool {
+    static final /* synthetic */ boolean $assertionsDisabled = false;
+    private static final Executor executor = new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60, TimeUnit.SECONDS, new SynchronousQueue(), Util.threadFactory("OkHttp ConnectionPool", true));
+    private final Runnable cleanupRunnable;
+    boolean cleanupRunning;
+    private final Deque<RealConnection> connections;
+    private final long keepAliveDurationNs;
+    private final int maxIdleConnections;
+    final RouteDatabase routeDatabase;
+
+    public ConnectionPool() {
+        this(5, 5L, TimeUnit.MINUTES);
+    }
+
+    public ConnectionPool(int i, long j, TimeUnit timeUnit) {
+        this.cleanupRunnable = new Runnable() { // from class: com.mbridge.msdk.thrid.okhttp.ConnectionPool.1
+            @Override // java.lang.Runnable
+            public void run() {
+                while (true) {
+                    long cleanup = ConnectionPool.this.cleanup(System.nanoTime());
+                    if (cleanup == -1) {
+                        return;
+                    }
+                    if (cleanup > 0) {
+                        long j2 = cleanup / 1000000;
+                        long j3 = cleanup - (1000000 * j2);
+                        synchronized (ConnectionPool.this) {
+                            try {
+                                ConnectionPool.this.wait(j2, (int) j3);
+                            } catch (InterruptedException unused) {
+                            }
+                        }
+                    }
+                }
+            }
+        };
+        this.connections = new ArrayDeque();
+        this.routeDatabase = new RouteDatabase();
+        this.maxIdleConnections = i;
+        this.keepAliveDurationNs = timeUnit.toNanos(j);
+        if (j > 0) {
+            return;
+        }
+        throw new IllegalArgumentException("keepAliveDuration <= 0: " + j);
+    }
+
+    public synchronized int idleConnectionCount() {
+        int i;
+        Iterator<RealConnection> it = this.connections.iterator();
+        i = 0;
+        while (it.hasNext()) {
+            if (it.next().allocations.isEmpty()) {
+                i++;
+            }
+        }
+        return i;
+    }
+
+    public synchronized int connectionCount() {
+        return this.connections.size();
+    }
+
+    public RealConnection get(Address address, StreamAllocation streamAllocation, Route route) {
+        for (RealConnection realConnection : this.connections) {
+            if (realConnection.isEligible(address, route)) {
+                streamAllocation.acquire(realConnection, true);
+                return realConnection;
+            }
+        }
+        return null;
+    }
+
+    public Socket deduplicate(Address address, StreamAllocation streamAllocation) {
+        for (RealConnection realConnection : this.connections) {
+            if (realConnection.isEligible(address, null) && realConnection.isMultiplexed() && realConnection != streamAllocation.connection()) {
+                return streamAllocation.releaseAndAcquire(realConnection);
+            }
+        }
+        return null;
+    }
+
+    public void put(RealConnection realConnection) {
+        if (!this.cleanupRunning) {
+            this.cleanupRunning = true;
+            executor.execute(this.cleanupRunnable);
+        }
+        this.connections.add(realConnection);
+    }
+
+    public boolean connectionBecameIdle(RealConnection realConnection) {
+        if (realConnection.noNewStreams || this.maxIdleConnections == 0) {
+            this.connections.remove(realConnection);
+            return true;
+        }
+        notifyAll();
+        return false;
+    }
+
+    public void evictAll() {
+        ArrayList arrayList = new ArrayList();
+        synchronized (this) {
+            try {
+                Iterator<RealConnection> it = this.connections.iterator();
+                while (it.hasNext()) {
+                    RealConnection next = it.next();
+                    if (next.allocations.isEmpty()) {
+                        next.noNewStreams = true;
+                        arrayList.add(next);
+                        it.remove();
+                    }
+                }
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+        Iterator it2 = arrayList.iterator();
+        while (it2.hasNext()) {
+            Util.closeQuietly(((RealConnection) it2.next()).socket());
+        }
+    }
+
+    public long cleanup(long j) {
+        synchronized (this) {
+            try {
+                RealConnection realConnection = null;
+                long j2 = Long.MIN_VALUE;
+                int i = 0;
+                int i2 = 0;
+                for (RealConnection realConnection2 : this.connections) {
+                    if (pruneAndGetAllocationCount(realConnection2, j) > 0) {
+                        i2++;
+                    } else {
+                        i++;
+                        long j3 = j - realConnection2.idleAtNanos;
+                        if (j3 > j2) {
+                            realConnection = realConnection2;
+                            j2 = j3;
+                        }
+                    }
+                }
+                long j4 = this.keepAliveDurationNs;
+                if (j2 < j4 && i <= this.maxIdleConnections) {
+                    if (i > 0) {
+                        return j4 - j2;
+                    }
+                    if (i2 > 0) {
+                        return j4;
+                    }
+                    this.cleanupRunning = false;
+                    return -1L;
+                }
+                this.connections.remove(realConnection);
+                Util.closeQuietly(realConnection.socket());
+                return 0L;
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+    }
+
+    private int pruneAndGetAllocationCount(RealConnection realConnection, long j) {
+        List<Reference<StreamAllocation>> list = realConnection.allocations;
+        int i = 0;
+        while (i < list.size()) {
+            Reference<StreamAllocation> reference = list.get(i);
+            if (reference.get() != null) {
+                i++;
+            } else {
+                Platform.get().logCloseableLeak("A connection to " + realConnection.route().address().url() + " was leaked. Did you forget to close a response body?", ((StreamAllocation.StreamAllocationReference) reference).callStackTrace);
+                list.remove(i);
+                realConnection.noNewStreams = true;
+                if (list.isEmpty()) {
+                    realConnection.idleAtNanos = j - this.keepAliveDurationNs;
+                    return 0;
+                }
+            }
+        }
+        return list.size();
+    }
+}

decompiled/sources/com/mbridge/msdk/thrid/okhttp/ConnectionSpec.java

@@ -0,0 +1,244 @@
+package com.mbridge.msdk.thrid.okhttp;
+
+import com.ironsource.mediationsdk.logger.IronSourceError;
+import com.mbridge.msdk.thrid.okhttp.internal.Util;
+import java.util.Arrays;
+import java.util.List;
+import javax.net.ssl.SSLSocket;
+
+/* loaded from: classes4.dex */
+public final class ConnectionSpec {
+    private static final CipherSuite[] APPROVED_CIPHER_SUITES;
+    public static final ConnectionSpec CLEARTEXT;
+    public static final ConnectionSpec COMPATIBLE_TLS;
+    public static final ConnectionSpec MODERN_TLS;
+    private static final CipherSuite[] RESTRICTED_CIPHER_SUITES;
+    public static final ConnectionSpec RESTRICTED_TLS;
+    final String[] cipherSuites;
+    final boolean supportsTlsExtensions;
+    final boolean tls;
+    final String[] tlsVersions;
+
+    public boolean isTls() {
+        return this.tls;
+    }
+
+    public boolean supportsTlsExtensions() {
+        return this.supportsTlsExtensions;
+    }
+
+    static {
+        CipherSuite cipherSuite = CipherSuite.TLS_AES_128_GCM_SHA256;
+        CipherSuite cipherSuite2 = CipherSuite.TLS_AES_256_GCM_SHA384;
+        CipherSuite cipherSuite3 = CipherSuite.TLS_CHACHA20_POLY1305_SHA256;
+        CipherSuite cipherSuite4 = CipherSuite.TLS_AES_128_CCM_SHA256;
+        CipherSuite cipherSuite5 = CipherSuite.TLS_AES_256_CCM_8_SHA256;
+        CipherSuite cipherSuite6 = CipherSuite.TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256;
+        CipherSuite cipherSuite7 = CipherSuite.TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256;
+        CipherSuite cipherSuite8 = CipherSuite.TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384;
+        CipherSuite cipherSuite9 = CipherSuite.TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384;
+        CipherSuite cipherSuite10 = CipherSuite.TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256;
+        CipherSuite cipherSuite11 = CipherSuite.TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256;
+        CipherSuite[] cipherSuiteArr = {cipherSuite, cipherSuite2, cipherSuite3, cipherSuite4, cipherSuite5, cipherSuite6, cipherSuite7, cipherSuite8, cipherSuite9, cipherSuite10, cipherSuite11};
+        RESTRICTED_CIPHER_SUITES = cipherSuiteArr;
+        CipherSuite[] cipherSuiteArr2 = {cipherSuite, cipherSuite2, cipherSuite3, cipherSuite4, cipherSuite5, cipherSuite6, cipherSuite7, cipherSuite8, cipherSuite9, cipherSuite10, cipherSuite11, CipherSuite.TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA, CipherSuite.TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA, CipherSuite.TLS_RSA_WITH_AES_128_GCM_SHA256, CipherSuite.TLS_RSA_WITH_AES_256_GCM_SHA384, CipherSuite.TLS_RSA_WITH_AES_128_CBC_SHA, CipherSuite.TLS_RSA_WITH_AES_256_CBC_SHA, CipherSuite.TLS_RSA_WITH_3DES_EDE_CBC_SHA};
+        APPROVED_CIPHER_SUITES = cipherSuiteArr2;
+        Builder cipherSuites = new Builder(true).cipherSuites(cipherSuiteArr);
+        TlsVersion tlsVersion = TlsVersion.TLS_1_3;
+        TlsVersion tlsVersion2 = TlsVersion.TLS_1_2;
+        RESTRICTED_TLS = cipherSuites.tlsVersions(tlsVersion, tlsVersion2).supportsTlsExtensions(true).build();
+        Builder cipherSuites2 = new Builder(true).cipherSuites(cipherSuiteArr2);
+        TlsVersion tlsVersion3 = TlsVersion.TLS_1_1;
+        TlsVersion tlsVersion4 = TlsVersion.TLS_1_0;
+        MODERN_TLS = cipherSuites2.tlsVersions(tlsVersion, tlsVersion2, tlsVersion3, tlsVersion4).supportsTlsExtensions(true).build();
+        COMPATIBLE_TLS = new Builder(true).cipherSuites(cipherSuiteArr2).tlsVersions(tlsVersion4).supportsTlsExtensions(true).build();
+        CLEARTEXT = new Builder(false).build();
+    }
+
+    public ConnectionSpec(Builder builder) {
+        this.tls = builder.tls;
+        this.cipherSuites = builder.cipherSuites;
+        this.tlsVersions = builder.tlsVersions;
+        this.supportsTlsExtensions = builder.supportsTlsExtensions;
+    }
+
+    public List<CipherSuite> cipherSuites() {
+        String[] strArr = this.cipherSuites;
+        if (strArr != null) {
+            return CipherSuite.forJavaNames(strArr);
+        }
+        return null;
+    }
+
+    public List<TlsVersion> tlsVersions() {
+        String[] strArr = this.tlsVersions;
+        if (strArr != null) {
+            return TlsVersion.forJavaNames(strArr);
+        }
+        return null;
+    }
+
+    public void apply(SSLSocket sSLSocket, boolean z) {
+        ConnectionSpec supportedSpec = supportedSpec(sSLSocket, z);
+        String[] strArr = supportedSpec.tlsVersions;
+        if (strArr != null) {
+            sSLSocket.setEnabledProtocols(strArr);
+        }
+        String[] strArr2 = supportedSpec.cipherSuites;
+        if (strArr2 != null) {
+            sSLSocket.setEnabledCipherSuites(strArr2);
+        }
+    }
+
+    private ConnectionSpec supportedSpec(SSLSocket sSLSocket, boolean z) {
+        String[] enabledCipherSuites;
+        String[] enabledProtocols;
+        if (this.cipherSuites != null) {
+            enabledCipherSuites = Util.intersect(CipherSuite.ORDER_BY_NAME, sSLSocket.getEnabledCipherSuites(), this.cipherSuites);
+        } else {
+            enabledCipherSuites = sSLSocket.getEnabledCipherSuites();
+        }
+        if (this.tlsVersions != null) {
+            enabledProtocols = Util.intersect(Util.NATURAL_ORDER, sSLSocket.getEnabledProtocols(), this.tlsVersions);
+        } else {
+            enabledProtocols = sSLSocket.getEnabledProtocols();
+        }
+        String[] supportedCipherSuites = sSLSocket.getSupportedCipherSuites();
+        int indexOf = Util.indexOf(CipherSuite.ORDER_BY_NAME, supportedCipherSuites, "TLS_FALLBACK_SCSV");
+        if (z && indexOf != -1) {
+            enabledCipherSuites = Util.concat(enabledCipherSuites, supportedCipherSuites[indexOf]);
+        }
+        return new Builder(this).cipherSuites(enabledCipherSuites).tlsVersions(enabledProtocols).build();
+    }
+
+    public boolean isCompatible(SSLSocket sSLSocket) {
+        if (!this.tls) {
+            return false;
+        }
+        String[] strArr = this.tlsVersions;
+        if (strArr != null && !Util.nonEmptyIntersection(Util.NATURAL_ORDER, strArr, sSLSocket.getEnabledProtocols())) {
+            return false;
+        }
+        String[] strArr2 = this.cipherSuites;
+        return strArr2 == null || Util.nonEmptyIntersection(CipherSuite.ORDER_BY_NAME, strArr2, sSLSocket.getEnabledCipherSuites());
+    }
+
+    public boolean equals(Object obj) {
+        if (!(obj instanceof ConnectionSpec)) {
+            return false;
+        }
+        if (obj == this) {
+            return true;
+        }
+        ConnectionSpec connectionSpec = (ConnectionSpec) obj;
+        boolean z = this.tls;
+        if (z != connectionSpec.tls) {
+            return false;
+        }
+        return !z || (Arrays.equals(this.cipherSuites, connectionSpec.cipherSuites) && Arrays.equals(this.tlsVersions, connectionSpec.tlsVersions) && this.supportsTlsExtensions == connectionSpec.supportsTlsExtensions);
+    }
+
+    public int hashCode() {
+        if (this.tls) {
+            return ((((IronSourceError.ERROR_NON_EXISTENT_INSTANCE + Arrays.hashCode(this.cipherSuites)) * 31) + Arrays.hashCode(this.tlsVersions)) * 31) + (!this.supportsTlsExtensions ? 1 : 0);
+        }
+        return 17;
+    }
+
+    public String toString() {
+        if (!this.tls) {
+            return "ConnectionSpec()";
+        }
+        return "ConnectionSpec(cipherSuites=" + (this.cipherSuites != null ? cipherSuites().toString() : "[all enabled]") + ", tlsVersions=" + (this.tlsVersions != null ? tlsVersions().toString() : "[all enabled]") + ", supportsTlsExtensions=" + this.supportsTlsExtensions + ")";
+    }
+
+    public static final class Builder {
+        String[] cipherSuites;
+        boolean supportsTlsExtensions;
+        boolean tls;
+        String[] tlsVersions;
+
+        public Builder(boolean z) {
+            this.tls = z;
+        }
+
+        public Builder(ConnectionSpec connectionSpec) {
+            this.tls = connectionSpec.tls;
+            this.cipherSuites = connectionSpec.cipherSuites;
+            this.tlsVersions = connectionSpec.tlsVersions;
+            this.supportsTlsExtensions = connectionSpec.supportsTlsExtensions;
+        }
+
+        public Builder allEnabledCipherSuites() {
+            if (!this.tls) {
+                throw new IllegalStateException("no cipher suites for cleartext connections");
+            }
+            this.cipherSuites = null;
+            return this;
+        }
+
+        public Builder cipherSuites(CipherSuite... cipherSuiteArr) {
+            if (!this.tls) {
+                throw new IllegalStateException("no cipher suites for cleartext connections");
+            }
+            String[] strArr = new String[cipherSuiteArr.length];
+            for (int i = 0; i < cipherSuiteArr.length; i++) {
+                strArr[i] = cipherSuiteArr[i].javaName;
+            }
+            return cipherSuites(strArr);
+        }
+
+        public Builder cipherSuites(String... strArr) {
+            if (!this.tls) {
+                throw new IllegalStateException("no cipher suites for cleartext connections");
+            }
+            if (strArr.length == 0) {
+                throw new IllegalArgumentException("At least one cipher suite is required");
+            }
+            this.cipherSuites = (String[]) strArr.clone();
+            return this;
+        }
+
+        public Builder allEnabledTlsVersions() {
+            if (!this.tls) {
+                throw new IllegalStateException("no TLS versions for cleartext connections");
+            }
+            this.tlsVersions = null;
+            return this;
+        }
+
+        public Builder tlsVersions(TlsVersion... tlsVersionArr) {
+            if (!this.tls) {
+                throw new IllegalStateException("no TLS versions for cleartext connections");
+            }
+            String[] strArr = new String[tlsVersionArr.length];
+            for (int i = 0; i < tlsVersionArr.length; i++) {
+                strArr[i] = tlsVersionArr[i].javaName;
+            }
+            return tlsVersions(strArr);
+        }
+
+        public Builder tlsVersions(String... strArr) {
+            if (!this.tls) {
+                throw new IllegalStateException("no TLS versions for cleartext connections");
+            }
+            if (strArr.length == 0) {
+                throw new IllegalArgumentException("At least one TLS version is required");
+            }
+            this.tlsVersions = (String[]) strArr.clone();
+            return this;
+        }
+
+        public Builder supportsTlsExtensions(boolean z) {
+            if (!this.tls) {
+                throw new IllegalStateException("no TLS extensions for cleartext connections");
+            }
+            this.supportsTlsExtensions = z;
+            return this;
+        }
+
+        public ConnectionSpec build() {
+            return new ConnectionSpec(this);
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/thrid/okhttp/Cookie.java

@@ -0,0 +1,419 @@
+package com.mbridge.msdk.thrid.okhttp;
+
+import com.ironsource.mediationsdk.logger.IronSourceError;
+import com.ironsource.nb;
+import com.mbridge.msdk.thrid.okhttp.internal.Util;
+import com.mbridge.msdk.thrid.okhttp.internal.http.HttpDate;
+import csdk.gluads.Consts;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Date;
+import java.util.GregorianCalendar;
+import java.util.List;
+import java.util.Locale;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import org.apache.http.cookie.SM;
+
+/* loaded from: classes4.dex */
+public final class Cookie {
+    private final String domain;
+    private final long expiresAt;
+    private final boolean hostOnly;
+    private final boolean httpOnly;
+    private final String name;
+    private final String path;
+    private final boolean persistent;
+    private final boolean secure;
+    private final String value;
+    private static final Pattern YEAR_PATTERN = Pattern.compile("(\\d{2,4})[^\\d]*");
+    private static final Pattern MONTH_PATTERN = Pattern.compile("(?i)(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec).*");
+    private static final Pattern DAY_OF_MONTH_PATTERN = Pattern.compile("(\\d{1,2})[^\\d]*");
+    private static final Pattern TIME_PATTERN = Pattern.compile("(\\d{1,2}):(\\d{1,2}):(\\d{1,2})[^\\d]*");
+
+    public String domain() {
+        return this.domain;
+    }
+
+    public long expiresAt() {
+        return this.expiresAt;
+    }
+
+    public boolean hostOnly() {
+        return this.hostOnly;
+    }
+
+    public boolean httpOnly() {
+        return this.httpOnly;
+    }
+
+    public String name() {
+        return this.name;
+    }
+
+    public String path() {
+        return this.path;
+    }
+
+    public boolean persistent() {
+        return this.persistent;
+    }
+
+    public boolean secure() {
+        return this.secure;
+    }
+
+    public String value() {
+        return this.value;
+    }
+
+    private Cookie(String str, String str2, long j, String str3, String str4, boolean z, boolean z2, boolean z3, boolean z4) {
+        this.name = str;
+        this.value = str2;
+        this.expiresAt = j;
+        this.domain = str3;
+        this.path = str4;
+        this.secure = z;
+        this.httpOnly = z2;
+        this.hostOnly = z3;
+        this.persistent = z4;
+    }
+
+    public Cookie(Builder builder) {
+        String str = builder.name;
+        if (str == null) {
+            throw new NullPointerException("builder.name == null");
+        }
+        String str2 = builder.value;
+        if (str2 == null) {
+            throw new NullPointerException("builder.value == null");
+        }
+        String str3 = builder.domain;
+        if (str3 == null) {
+            throw new NullPointerException("builder.domain == null");
+        }
+        this.name = str;
+        this.value = str2;
+        this.expiresAt = builder.expiresAt;
+        this.domain = str3;
+        this.path = builder.path;
+        this.secure = builder.secure;
+        this.httpOnly = builder.httpOnly;
+        this.persistent = builder.persistent;
+        this.hostOnly = builder.hostOnly;
+    }
+
+    public boolean matches(HttpUrl httpUrl) {
+        boolean domainMatch;
+        if (this.hostOnly) {
+            domainMatch = httpUrl.host().equals(this.domain);
+        } else {
+            domainMatch = domainMatch(httpUrl.host(), this.domain);
+        }
+        if (domainMatch && pathMatch(httpUrl, this.path)) {
+            return !this.secure || httpUrl.isHttps();
+        }
+        return false;
+    }
+
+    private static boolean domainMatch(String str, String str2) {
+        if (str.equals(str2)) {
+            return true;
+        }
+        return str.endsWith(str2) && str.charAt((str.length() - str2.length()) - 1) == '.' && !Util.verifyAsIpAddress(str);
+    }
+
+    private static boolean pathMatch(HttpUrl httpUrl, String str) {
+        String encodedPath = httpUrl.encodedPath();
+        if (encodedPath.equals(str)) {
+            return true;
+        }
+        if (encodedPath.startsWith(str)) {
+            return str.endsWith("/") || encodedPath.charAt(str.length()) == '/';
+        }
+        return false;
+    }
+
+    public static Cookie parse(HttpUrl httpUrl, String str) {
+        return parse(System.currentTimeMillis(), httpUrl, str);
+    }
+
+    /* JADX WARN: Removed duplicated region for block: B:54:0x00ee  */
+    /* JADX WARN: Removed duplicated region for block: B:69:0x0129  */
+    /* JADX WARN: Removed duplicated region for block: B:71:0x00f1  */
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    public static com.mbridge.msdk.thrid.okhttp.Cookie parse(long r23, com.mbridge.msdk.thrid.okhttp.HttpUrl r25, java.lang.String r26) {
+        /*
+            Method dump skipped, instructions count: 310
+            To view this dump add '--comments-level debug' option
+        */
+        throw new UnsupportedOperationException("Method not decompiled: com.mbridge.msdk.thrid.okhttp.Cookie.parse(long, com.mbridge.msdk.thrid.okhttp.HttpUrl, java.lang.String):com.mbridge.msdk.thrid.okhttp.Cookie");
+    }
+
+    private static long parseExpires(String str, int i, int i2) {
+        int dateCharacterOffset = dateCharacterOffset(str, i, i2, false);
+        Matcher matcher = TIME_PATTERN.matcher(str);
+        int i3 = -1;
+        int i4 = -1;
+        int i5 = -1;
+        int i6 = -1;
+        int i7 = -1;
+        int i8 = -1;
+        while (dateCharacterOffset < i2) {
+            int dateCharacterOffset2 = dateCharacterOffset(str, dateCharacterOffset + 1, i2, true);
+            matcher.region(dateCharacterOffset, dateCharacterOffset2);
+            if (i4 == -1 && matcher.usePattern(TIME_PATTERN).matches()) {
+                i4 = Integer.parseInt(matcher.group(1));
+                i7 = Integer.parseInt(matcher.group(2));
+                i8 = Integer.parseInt(matcher.group(3));
+            } else if (i5 == -1 && matcher.usePattern(DAY_OF_MONTH_PATTERN).matches()) {
+                i5 = Integer.parseInt(matcher.group(1));
+            } else {
+                if (i6 == -1) {
+                    Pattern pattern = MONTH_PATTERN;
+                    if (matcher.usePattern(pattern).matches()) {
+                        i6 = pattern.pattern().indexOf(matcher.group(1).toLowerCase(Locale.US)) / 4;
+                    }
+                }
+                if (i3 == -1 && matcher.usePattern(YEAR_PATTERN).matches()) {
+                    i3 = Integer.parseInt(matcher.group(1));
+                }
+            }
+            dateCharacterOffset = dateCharacterOffset(str, dateCharacterOffset2 + 1, i2, false);
+        }
+        if (i3 >= 70 && i3 <= 99) {
+            i3 += 1900;
+        }
+        if (i3 >= 0 && i3 <= 69) {
+            i3 += 2000;
+        }
+        if (i3 < 1601) {
+            throw new IllegalArgumentException();
+        }
+        if (i6 == -1) {
+            throw new IllegalArgumentException();
+        }
+        if (i5 < 1 || i5 > 31) {
+            throw new IllegalArgumentException();
+        }
+        if (i4 < 0 || i4 > 23) {
+            throw new IllegalArgumentException();
+        }
+        if (i7 < 0 || i7 > 59) {
+            throw new IllegalArgumentException();
+        }
+        if (i8 < 0 || i8 > 59) {
+            throw new IllegalArgumentException();
+        }
+        GregorianCalendar gregorianCalendar = new GregorianCalendar(Util.UTC);
+        gregorianCalendar.setLenient(false);
+        gregorianCalendar.set(1, i3);
+        gregorianCalendar.set(2, i6 - 1);
+        gregorianCalendar.set(5, i5);
+        gregorianCalendar.set(11, i4);
+        gregorianCalendar.set(12, i7);
+        gregorianCalendar.set(13, i8);
+        gregorianCalendar.set(14, 0);
+        return gregorianCalendar.getTimeInMillis();
+    }
+
+    private static int dateCharacterOffset(String str, int i, int i2, boolean z) {
+        while (i < i2) {
+            char charAt = str.charAt(i);
+            if (((charAt < ' ' && charAt != '\t') || charAt >= 127 || (charAt >= '0' && charAt <= '9') || ((charAt >= 'a' && charAt <= 'z') || ((charAt >= 'A' && charAt <= 'Z') || charAt == ':'))) == (!z)) {
+                return i;
+            }
+            i++;
+        }
+        return i2;
+    }
+
+    private static long parseMaxAge(String str) {
+        try {
+            long parseLong = Long.parseLong(str);
+            if (parseLong <= 0) {
+                return Long.MIN_VALUE;
+            }
+            return parseLong;
+        } catch (NumberFormatException e) {
+            if (str.matches("-?\\d+")) {
+                return str.startsWith("-") ? Long.MIN_VALUE : Long.MAX_VALUE;
+            }
+            throw e;
+        }
+    }
+
+    private static String parseDomain(String str) {
+        if (str.endsWith(Consts.STRING_PERIOD)) {
+            throw new IllegalArgumentException();
+        }
+        if (str.startsWith(Consts.STRING_PERIOD)) {
+            str = str.substring(1);
+        }
+        String canonicalizeHost = Util.canonicalizeHost(str);
+        if (canonicalizeHost != null) {
+            return canonicalizeHost;
+        }
+        throw new IllegalArgumentException();
+    }
+
+    public static List<Cookie> parseAll(HttpUrl httpUrl, Headers headers) {
+        List<String> values = headers.values(SM.SET_COOKIE);
+        int size = values.size();
+        ArrayList arrayList = null;
+        for (int i = 0; i < size; i++) {
+            Cookie parse = parse(httpUrl, values.get(i));
+            if (parse != null) {
+                if (arrayList == null) {
+                    arrayList = new ArrayList();
+                }
+                arrayList.add(parse);
+            }
+        }
+        if (arrayList != null) {
+            return Collections.unmodifiableList(arrayList);
+        }
+        return Collections.emptyList();
+    }
+
+    public static final class Builder {
+        String domain;
+        boolean hostOnly;
+        boolean httpOnly;
+        String name;
+        boolean persistent;
+        boolean secure;
+        String value;
+        long expiresAt = HttpDate.MAX_DATE;
+        String path = "/";
+
+        public Builder expiresAt(long j) {
+            if (j <= 0) {
+                j = Long.MIN_VALUE;
+            }
+            if (j > HttpDate.MAX_DATE) {
+                j = 253402300799999L;
+            }
+            this.expiresAt = j;
+            this.persistent = true;
+            return this;
+        }
+
+        public Builder httpOnly() {
+            this.httpOnly = true;
+            return this;
+        }
+
+        public Builder secure() {
+            this.secure = true;
+            return this;
+        }
+
+        public Builder name(String str) {
+            if (str == null) {
+                throw new NullPointerException("name == null");
+            }
+            if (!str.trim().equals(str)) {
+                throw new IllegalArgumentException("name is not trimmed");
+            }
+            this.name = str;
+            return this;
+        }
+
+        public Builder value(String str) {
+            if (str == null) {
+                throw new NullPointerException("value == null");
+            }
+            if (!str.trim().equals(str)) {
+                throw new IllegalArgumentException("value is not trimmed");
+            }
+            this.value = str;
+            return this;
+        }
+
+        public Builder domain(String str) {
+            return domain(str, false);
+        }
+
+        public Builder hostOnlyDomain(String str) {
+            return domain(str, true);
+        }
+
+        private Builder domain(String str, boolean z) {
+            if (str == null) {
+                throw new NullPointerException("domain == null");
+            }
+            String canonicalizeHost = Util.canonicalizeHost(str);
+            if (canonicalizeHost != null) {
+                this.domain = canonicalizeHost;
+                this.hostOnly = z;
+                return this;
+            }
+            throw new IllegalArgumentException("unexpected domain: " + str);
+        }
+
+        public Builder path(String str) {
+            if (!str.startsWith("/")) {
+                throw new IllegalArgumentException("path must start with '/'");
+            }
+            this.path = str;
+            return this;
+        }
+
+        public Cookie build() {
+            return new Cookie(this);
+        }
+    }
+
+    public String toString() {
+        return toString(false);
+    }
+
+    public String toString(boolean z) {
+        StringBuilder sb = new StringBuilder();
+        sb.append(this.name);
+        sb.append(nb.T);
+        sb.append(this.value);
+        if (this.persistent) {
+            if (this.expiresAt == Long.MIN_VALUE) {
+                sb.append("; max-age=0");
+            } else {
+                sb.append("; expires=");
+                sb.append(HttpDate.format(new Date(this.expiresAt)));
+            }
+        }
+        if (!this.hostOnly) {
+            sb.append("; domain=");
+            if (z) {
+                sb.append(Consts.STRING_PERIOD);
+            }
+            sb.append(this.domain);
+        }
+        sb.append("; path=");
+        sb.append(this.path);
+        if (this.secure) {
+            sb.append("; secure");
+        }
+        if (this.httpOnly) {
+            sb.append("; httponly");
+        }
+        return sb.toString();
+    }
+
+    public boolean equals(Object obj) {
+        if (!(obj instanceof Cookie)) {
+            return false;
+        }
+        Cookie cookie = (Cookie) obj;
+        return cookie.name.equals(this.name) && cookie.value.equals(this.value) && cookie.domain.equals(this.domain) && cookie.path.equals(this.path) && cookie.expiresAt == this.expiresAt && cookie.secure == this.secure && cookie.httpOnly == this.httpOnly && cookie.persistent == this.persistent && cookie.hostOnly == this.hostOnly;
+    }
+
+    public int hashCode() {
+        int hashCode = (((((((IronSourceError.ERROR_NON_EXISTENT_INSTANCE + this.name.hashCode()) * 31) + this.value.hashCode()) * 31) + this.domain.hashCode()) * 31) + this.path.hashCode()) * 31;
+        long j = this.expiresAt;
+        return ((((((((hashCode + ((int) (j ^ (j >>> 32)))) * 31) + (!this.secure ? 1 : 0)) * 31) + (!this.httpOnly ? 1 : 0)) * 31) + (!this.persistent ? 1 : 0)) * 31) + (!this.hostOnly ? 1 : 0);
+    }
+}

decompiled/sources/com/mbridge/msdk/thrid/okhttp/CookieJar.java

@@ -0,0 +1,22 @@
+package com.mbridge.msdk.thrid.okhttp;
+
+import java.util.Collections;
+import java.util.List;
+
+/* loaded from: classes4.dex */
+public interface CookieJar {
+    public static final CookieJar NO_COOKIES = new CookieJar() { // from class: com.mbridge.msdk.thrid.okhttp.CookieJar.1
+        @Override // com.mbridge.msdk.thrid.okhttp.CookieJar
+        public void saveFromResponse(HttpUrl httpUrl, List<Cookie> list) {
+        }
+
+        @Override // com.mbridge.msdk.thrid.okhttp.CookieJar
+        public List<Cookie> loadForRequest(HttpUrl httpUrl) {
+            return Collections.emptyList();
+        }
+    };
+
+    List<Cookie> loadForRequest(HttpUrl httpUrl);
+
+    void saveFromResponse(HttpUrl httpUrl, List<Cookie> list);
+}

decompiled/sources/com/mbridge/msdk/thrid/okhttp/Credentials.java

@@ -0,0 +1,20 @@
+package com.mbridge.msdk.thrid.okhttp;
+
+import com.facebook.internal.security.CertificateUtil;
+import com.mbridge.msdk.thrid.okhttp.internal.Util;
+import com.mbridge.msdk.thrid.okio.ByteString;
+import java.nio.charset.Charset;
+
+/* loaded from: classes4.dex */
+public final class Credentials {
+    private Credentials() {
+    }
+
+    public static String basic(String str, String str2) {
+        return basic(str, str2, Util.ISO_8859_1);
+    }
+
+    public static String basic(String str, String str2, Charset charset) {
+        return "Basic " + ByteString.encodeString(str + CertificateUtil.DELIMITER + str2, charset).base64();
+    }
+}

decompiled/sources/com/mbridge/msdk/thrid/okhttp/Dispatcher.java

@@ -0,0 +1,205 @@
+package com.mbridge.msdk.thrid.okhttp;
+
+import com.mbridge.msdk.thrid.okhttp.RealCall;
+import com.mbridge.msdk.thrid.okhttp.internal.Util;
+import java.util.ArrayDeque;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Deque;
+import java.util.Iterator;
+import java.util.List;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.SynchronousQueue;
+import java.util.concurrent.ThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;
+
+/* loaded from: classes4.dex */
+public final class Dispatcher {
+    static final /* synthetic */ boolean $assertionsDisabled = false;
+    private ExecutorService executorService;
+    private Runnable idleCallback;
+    private int maxRequests = 64;
+    private int maxRequestsPerHost = 5;
+    private final Deque<RealCall.AsyncCall> readyAsyncCalls = new ArrayDeque();
+    private final Deque<RealCall.AsyncCall> runningAsyncCalls = new ArrayDeque();
+    private final Deque<RealCall> runningSyncCalls = new ArrayDeque();
+
+    public Dispatcher(ExecutorService executorService) {
+        this.executorService = executorService;
+    }
+
+    public Dispatcher() {
+    }
+
+    public synchronized ExecutorService executorService() {
+        try {
+            if (this.executorService == null) {
+                this.executorService = new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60L, TimeUnit.SECONDS, new SynchronousQueue(), Util.threadFactory("OkHttp Dispatcher", false));
+            }
+        } catch (Throwable th) {
+            throw th;
+        }
+        return this.executorService;
+    }
+
+    public void setMaxRequests(int i) {
+        if (i < 1) {
+            throw new IllegalArgumentException("max < 1: " + i);
+        }
+        synchronized (this) {
+            this.maxRequests = i;
+        }
+        promoteAndExecute();
+    }
+
+    public synchronized int getMaxRequests() {
+        return this.maxRequests;
+    }
+
+    public void setMaxRequestsPerHost(int i) {
+        if (i < 1) {
+            throw new IllegalArgumentException("max < 1: " + i);
+        }
+        synchronized (this) {
+            this.maxRequestsPerHost = i;
+        }
+        promoteAndExecute();
+    }
+
+    public synchronized int getMaxRequestsPerHost() {
+        return this.maxRequestsPerHost;
+    }
+
+    public synchronized void setIdleCallback(Runnable runnable) {
+        this.idleCallback = runnable;
+    }
+
+    public void enqueue(RealCall.AsyncCall asyncCall) {
+        synchronized (this) {
+            this.readyAsyncCalls.add(asyncCall);
+        }
+        promoteAndExecute();
+    }
+
+    public synchronized void cancelAll() {
+        try {
+            Iterator<RealCall.AsyncCall> it = this.readyAsyncCalls.iterator();
+            while (it.hasNext()) {
+                it.next().get().cancel();
+            }
+            Iterator<RealCall.AsyncCall> it2 = this.runningAsyncCalls.iterator();
+            while (it2.hasNext()) {
+                it2.next().get().cancel();
+            }
+            Iterator<RealCall> it3 = this.runningSyncCalls.iterator();
+            while (it3.hasNext()) {
+                it3.next().cancel();
+            }
+        } catch (Throwable th) {
+            throw th;
+        }
+    }
+
+    private boolean promoteAndExecute() {
+        int i;
+        boolean z;
+        ArrayList arrayList = new ArrayList();
+        synchronized (this) {
+            try {
+                Iterator<RealCall.AsyncCall> it = this.readyAsyncCalls.iterator();
+                while (it.hasNext()) {
+                    RealCall.AsyncCall next = it.next();
+                    if (this.runningAsyncCalls.size() >= this.maxRequests) {
+                        break;
+                    }
+                    if (runningCallsForHost(next) < this.maxRequestsPerHost) {
+                        it.remove();
+                        arrayList.add(next);
+                        this.runningAsyncCalls.add(next);
+                    }
+                }
+                z = runningCallsCount() > 0;
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+        int size = arrayList.size();
+        for (i = 0; i < size; i++) {
+            ((RealCall.AsyncCall) arrayList.get(i)).executeOn(executorService());
+        }
+        return z;
+    }
+
+    private int runningCallsForHost(RealCall.AsyncCall asyncCall) {
+        int i = 0;
+        for (RealCall.AsyncCall asyncCall2 : this.runningAsyncCalls) {
+            if (!asyncCall2.get().forWebSocket && asyncCall2.host().equals(asyncCall.host())) {
+                i++;
+            }
+        }
+        return i;
+    }
+
+    public synchronized void executed(RealCall realCall) {
+        this.runningSyncCalls.add(realCall);
+    }
+
+    public void finished(RealCall.AsyncCall asyncCall) {
+        finished(this.runningAsyncCalls, asyncCall);
+    }
+
+    public void finished(RealCall realCall) {
+        finished(this.runningSyncCalls, realCall);
+    }
+
+    private <T> void finished(Deque<T> deque, T t) {
+        Runnable runnable;
+        synchronized (this) {
+            if (!deque.remove(t)) {
+                throw new AssertionError("Call wasn't in-flight!");
+            }
+            runnable = this.idleCallback;
+        }
+        if (promoteAndExecute() || runnable == null) {
+            return;
+        }
+        runnable.run();
+    }
+
+    public synchronized List<Call> queuedCalls() {
+        ArrayList arrayList;
+        try {
+            arrayList = new ArrayList();
+            Iterator<RealCall.AsyncCall> it = this.readyAsyncCalls.iterator();
+            while (it.hasNext()) {
+                arrayList.add(it.next().get());
+            }
+        } catch (Throwable th) {
+            throw th;
+        }
+        return Collections.unmodifiableList(arrayList);
+    }
+
+    public synchronized List<Call> runningCalls() {
+        ArrayList arrayList;
+        try {
+            arrayList = new ArrayList();
+            arrayList.addAll(this.runningSyncCalls);
+            Iterator<RealCall.AsyncCall> it = this.runningAsyncCalls.iterator();
+            while (it.hasNext()) {
+                arrayList.add(it.next().get());
+            }
+        } catch (Throwable th) {
+            throw th;
+        }
+        return Collections.unmodifiableList(arrayList);
+    }
+
+    public synchronized int queuedCallsCount() {
+        return this.readyAsyncCalls.size();
+    }
+
+    public synchronized int runningCallsCount() {
+        return this.runningAsyncCalls.size() + this.runningSyncCalls.size();
+    }
+}

decompiled/sources/com/mbridge/msdk/thrid/okhttp/Dns.java

@@ -0,0 +1,27 @@
+package com.mbridge.msdk.thrid.okhttp;
+
+import java.net.InetAddress;
+import java.net.UnknownHostException;
+import java.util.Arrays;
+import java.util.List;
+
+/* loaded from: classes4.dex */
+public interface Dns {
+    public static final Dns SYSTEM = new Dns() { // from class: com.mbridge.msdk.thrid.okhttp.Dns.1
+        @Override // com.mbridge.msdk.thrid.okhttp.Dns
+        public List<InetAddress> lookup(String str) throws UnknownHostException {
+            if (str == null) {
+                throw new UnknownHostException("hostname == null");
+            }
+            try {
+                return Arrays.asList(InetAddress.getAllByName(str));
+            } catch (NullPointerException e) {
+                UnknownHostException unknownHostException = new UnknownHostException("Broken system behaviour for dns lookup of " + str);
+                unknownHostException.initCause(e);
+                throw unknownHostException;
+            }
+        }
+    };
+
+    List<InetAddress> lookup(String str) throws UnknownHostException;
+}

decompiled/sources/com/mbridge/msdk/thrid/okhttp/EventListener.java

@@ -0,0 +1,86 @@
+package com.mbridge.msdk.thrid.okhttp;
+
+import java.io.IOException;
+import java.net.InetAddress;
+import java.net.InetSocketAddress;
+import java.net.Proxy;
+import java.util.List;
+
+/* loaded from: classes4.dex */
+public abstract class EventListener {
+    public static final EventListener NONE = new EventListener() { // from class: com.mbridge.msdk.thrid.okhttp.EventListener.1
+    };
+
+    public interface Factory {
+        EventListener create(Call call);
+    }
+
+    public void callEnd(Call call) {
+    }
+
+    public void callFailed(Call call, IOException iOException) {
+    }
+
+    public void callStart(Call call) {
+    }
+
+    public void connectEnd(Call call, InetSocketAddress inetSocketAddress, Proxy proxy, Protocol protocol) {
+    }
+
+    public void connectFailed(Call call, InetSocketAddress inetSocketAddress, Proxy proxy, Protocol protocol, IOException iOException) {
+    }
+
+    public void connectStart(Call call, InetSocketAddress inetSocketAddress, Proxy proxy) {
+    }
+
+    public void connectionAcquired(Call call, Connection connection) {
+    }
+
+    public void connectionReleased(Call call, Connection connection) {
+    }
+
+    public void dnsEnd(Call call, String str, List<InetAddress> list) {
+    }
+
+    public void dnsStart(Call call, String str) {
+    }
+
+    public void requestBodyEnd(Call call, long j) {
+    }
+
+    public void requestBodyStart(Call call) {
+    }
+
+    public void requestHeadersEnd(Call call, Request request) {
+    }
+
+    public void requestHeadersStart(Call call) {
+    }
+
+    public void responseBodyEnd(Call call, long j) {
+    }
+
+    public void responseBodyStart(Call call) {
+    }
+
+    public void responseHeadersEnd(Call call, Response response) {
+    }
+
+    public void responseHeadersStart(Call call) {
+    }
+
+    public void secureConnectEnd(Call call, Handshake handshake) {
+    }
+
+    public void secureConnectStart(Call call) {
+    }
+
+    public static Factory factory(EventListener eventListener) {
+        return new Factory() { // from class: com.mbridge.msdk.thrid.okhttp.EventListener.2
+            @Override // com.mbridge.msdk.thrid.okhttp.EventListener.Factory
+            public EventListener create(Call call) {
+                return EventListener.this;
+            }
+        };
+    }
+}

decompiled/sources/com/mbridge/msdk/thrid/okhttp/FormBody.java

@@ -0,0 +1,124 @@
+package com.mbridge.msdk.thrid.okhttp;
+
+import com.mbridge.msdk.thrid.okhttp.internal.Util;
+import com.mbridge.msdk.thrid.okio.Buffer;
+import com.mbridge.msdk.thrid.okio.BufferedSink;
+import java.io.IOException;
+import java.nio.charset.Charset;
+import java.util.ArrayList;
+import java.util.List;
+
+/* loaded from: classes4.dex */
+public final class FormBody extends RequestBody {
+    private static final MediaType CONTENT_TYPE = MediaType.get("application/x-www-form-urlencoded");
+    private final List<String> encodedNames;
+    private final List<String> encodedValues;
+
+    @Override // com.mbridge.msdk.thrid.okhttp.RequestBody
+    public MediaType contentType() {
+        return CONTENT_TYPE;
+    }
+
+    public FormBody(List<String> list, List<String> list2) {
+        this.encodedNames = Util.immutableList(list);
+        this.encodedValues = Util.immutableList(list2);
+    }
+
+    public int size() {
+        return this.encodedNames.size();
+    }
+
+    public String encodedName(int i) {
+        return this.encodedNames.get(i);
+    }
+
+    public String name(int i) {
+        return HttpUrl.percentDecode(encodedName(i), true);
+    }
+
+    public String encodedValue(int i) {
+        return this.encodedValues.get(i);
+    }
+
+    public String value(int i) {
+        return HttpUrl.percentDecode(encodedValue(i), true);
+    }
+
+    @Override // com.mbridge.msdk.thrid.okhttp.RequestBody
+    public long contentLength() {
+        return writeOrCountBytes(null, true);
+    }
+
+    @Override // com.mbridge.msdk.thrid.okhttp.RequestBody
+    public void writeTo(BufferedSink bufferedSink) throws IOException {
+        writeOrCountBytes(bufferedSink, false);
+    }
+
+    private long writeOrCountBytes(BufferedSink bufferedSink, boolean z) {
+        Buffer buffer;
+        if (z) {
+            buffer = new Buffer();
+        } else {
+            buffer = bufferedSink.buffer();
+        }
+        int size = this.encodedNames.size();
+        for (int i = 0; i < size; i++) {
+            if (i > 0) {
+                buffer.writeByte(38);
+            }
+            buffer.writeUtf8(this.encodedNames.get(i));
+            buffer.writeByte(61);
+            buffer.writeUtf8(this.encodedValues.get(i));
+        }
+        if (!z) {
+            return 0L;
+        }
+        long size2 = buffer.size();
+        buffer.clear();
+        return size2;
+    }
+
+    public static final class Builder {
+        private final Charset charset;
+        private final List<String> names;
+        private final List<String> values;
+
+        public Builder() {
+            this(null);
+        }
+
+        public Builder(Charset charset) {
+            this.names = new ArrayList();
+            this.values = new ArrayList();
+            this.charset = charset;
+        }
+
+        public Builder add(String str, String str2) {
+            if (str == null) {
+                throw new NullPointerException("name == null");
+            }
+            if (str2 == null) {
+                throw new NullPointerException("value == null");
+            }
+            this.names.add(HttpUrl.canonicalize(str, " \"':;<=>@[]^`{}|/\\?#&!$(),~", false, false, true, true, this.charset));
+            this.values.add(HttpUrl.canonicalize(str2, " \"':;<=>@[]^`{}|/\\?#&!$(),~", false, false, true, true, this.charset));
+            return this;
+        }
+
+        public Builder addEncoded(String str, String str2) {
+            if (str == null) {
+                throw new NullPointerException("name == null");
+            }
+            if (str2 == null) {
+                throw new NullPointerException("value == null");
+            }
+            this.names.add(HttpUrl.canonicalize(str, " \"':;<=>@[]^`{}|/\\?#&!$(),~", true, false, true, true, this.charset));
+            this.values.add(HttpUrl.canonicalize(str2, " \"':;<=>@[]^`{}|/\\?#&!$(),~", true, false, true, true, this.charset));
+            return this;
+        }
+
+        public FormBody build() {
+            return new FormBody(this.names, this.values);
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/thrid/okhttp/Handshake.java

@@ -0,0 +1,118 @@
+package com.mbridge.msdk.thrid.okhttp;
+
+import com.ironsource.mediationsdk.logger.IronSourceError;
+import com.mbridge.msdk.thrid.okhttp.internal.Util;
+import java.io.IOException;
+import java.security.Principal;
+import java.security.cert.Certificate;
+import java.security.cert.X509Certificate;
+import java.util.Collections;
+import java.util.List;
+import javax.net.ssl.SSLPeerUnverifiedException;
+import javax.net.ssl.SSLSession;
+
+/* loaded from: classes4.dex */
+public final class Handshake {
+    private final CipherSuite cipherSuite;
+    private final List<Certificate> localCertificates;
+    private final List<Certificate> peerCertificates;
+    private final TlsVersion tlsVersion;
+
+    public CipherSuite cipherSuite() {
+        return this.cipherSuite;
+    }
+
+    public List<Certificate> localCertificates() {
+        return this.localCertificates;
+    }
+
+    public List<Certificate> peerCertificates() {
+        return this.peerCertificates;
+    }
+
+    public TlsVersion tlsVersion() {
+        return this.tlsVersion;
+    }
+
+    private Handshake(TlsVersion tlsVersion, CipherSuite cipherSuite, List<Certificate> list, List<Certificate> list2) {
+        this.tlsVersion = tlsVersion;
+        this.cipherSuite = cipherSuite;
+        this.peerCertificates = list;
+        this.localCertificates = list2;
+    }
+
+    public static Handshake get(SSLSession sSLSession) throws IOException {
+        Certificate[] certificateArr;
+        List emptyList;
+        List emptyList2;
+        String cipherSuite = sSLSession.getCipherSuite();
+        if (cipherSuite == null) {
+            throw new IllegalStateException("cipherSuite == null");
+        }
+        if ("SSL_NULL_WITH_NULL_NULL".equals(cipherSuite)) {
+            throw new IOException("cipherSuite == SSL_NULL_WITH_NULL_NULL");
+        }
+        CipherSuite forJavaName = CipherSuite.forJavaName(cipherSuite);
+        String protocol = sSLSession.getProtocol();
+        if (protocol == null) {
+            throw new IllegalStateException("tlsVersion == null");
+        }
+        if ("NONE".equals(protocol)) {
+            throw new IOException("tlsVersion == NONE");
+        }
+        TlsVersion forJavaName2 = TlsVersion.forJavaName(protocol);
+        try {
+            certificateArr = sSLSession.getPeerCertificates();
+        } catch (SSLPeerUnverifiedException unused) {
+            certificateArr = null;
+        }
+        if (certificateArr != null) {
+            emptyList = Util.immutableList(certificateArr);
+        } else {
+            emptyList = Collections.emptyList();
+        }
+        Certificate[] localCertificates = sSLSession.getLocalCertificates();
+        if (localCertificates != null) {
+            emptyList2 = Util.immutableList(localCertificates);
+        } else {
+            emptyList2 = Collections.emptyList();
+        }
+        return new Handshake(forJavaName2, forJavaName, emptyList, emptyList2);
+    }
+
+    public static Handshake get(TlsVersion tlsVersion, CipherSuite cipherSuite, List<Certificate> list, List<Certificate> list2) {
+        if (tlsVersion == null) {
+            throw new NullPointerException("tlsVersion == null");
+        }
+        if (cipherSuite == null) {
+            throw new NullPointerException("cipherSuite == null");
+        }
+        return new Handshake(tlsVersion, cipherSuite, Util.immutableList(list), Util.immutableList(list2));
+    }
+
+    public Principal peerPrincipal() {
+        if (this.peerCertificates.isEmpty()) {
+            return null;
+        }
+        return ((X509Certificate) this.peerCertificates.get(0)).getSubjectX500Principal();
+    }
+
+    public Principal localPrincipal() {
+        if (this.localCertificates.isEmpty()) {
+            return null;
+        }
+        return ((X509Certificate) this.localCertificates.get(0)).getSubjectX500Principal();
+    }
+
+    public boolean equals(Object obj) {
+        if (!(obj instanceof Handshake)) {
+            return false;
+        }
+        Handshake handshake = (Handshake) obj;
+        return this.tlsVersion.equals(handshake.tlsVersion) && this.cipherSuite.equals(handshake.cipherSuite) && this.peerCertificates.equals(handshake.peerCertificates) && this.localCertificates.equals(handshake.localCertificates);
+    }
+
+    public int hashCode() {
+        return ((((((IronSourceError.ERROR_NON_EXISTENT_INSTANCE + this.tlsVersion.hashCode()) * 31) + this.cipherSuite.hashCode()) * 31) + this.peerCertificates.hashCode()) * 31) + this.localCertificates.hashCode();
+    }
+}

decompiled/sources/com/mbridge/msdk/thrid/okhttp/Headers.java

@@ -0,0 +1,310 @@
+package com.mbridge.msdk.thrid.okhttp;
+
+import com.facebook.internal.security.CertificateUtil;
+import com.mbridge.msdk.thrid.okhttp.internal.Util;
+import com.mbridge.msdk.thrid.okhttp.internal.http.HttpDate;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Date;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Set;
+import java.util.TreeMap;
+import java.util.TreeSet;
+
+/* loaded from: classes4.dex */
+public final class Headers {
+    private final String[] namesAndValues;
+
+    public Headers(Builder builder) {
+        List<String> list = builder.namesAndValues;
+        this.namesAndValues = (String[]) list.toArray(new String[list.size()]);
+    }
+
+    private Headers(String[] strArr) {
+        this.namesAndValues = strArr;
+    }
+
+    public String get(String str) {
+        return get(this.namesAndValues, str);
+    }
+
+    public Date getDate(String str) {
+        String str2 = get(str);
+        if (str2 != null) {
+            return HttpDate.parse(str2);
+        }
+        return null;
+    }
+
+    public int size() {
+        return this.namesAndValues.length / 2;
+    }
+
+    public String name(int i) {
+        return this.namesAndValues[i * 2];
+    }
+
+    public String value(int i) {
+        return this.namesAndValues[(i * 2) + 1];
+    }
+
+    public Set<String> names() {
+        TreeSet treeSet = new TreeSet(String.CASE_INSENSITIVE_ORDER);
+        int size = size();
+        for (int i = 0; i < size; i++) {
+            treeSet.add(name(i));
+        }
+        return Collections.unmodifiableSet(treeSet);
+    }
+
+    public List<String> values(String str) {
+        int size = size();
+        ArrayList arrayList = null;
+        for (int i = 0; i < size; i++) {
+            if (str.equalsIgnoreCase(name(i))) {
+                if (arrayList == null) {
+                    arrayList = new ArrayList(2);
+                }
+                arrayList.add(value(i));
+            }
+        }
+        if (arrayList != null) {
+            return Collections.unmodifiableList(arrayList);
+        }
+        return Collections.emptyList();
+    }
+
+    public long byteCount() {
+        String[] strArr = this.namesAndValues;
+        long length = strArr.length * 2;
+        for (int i = 0; i < strArr.length; i++) {
+            length += this.namesAndValues[i].length();
+        }
+        return length;
+    }
+
+    public Builder newBuilder() {
+        Builder builder = new Builder();
+        Collections.addAll(builder.namesAndValues, this.namesAndValues);
+        return builder;
+    }
+
+    public boolean equals(Object obj) {
+        return (obj instanceof Headers) && Arrays.equals(((Headers) obj).namesAndValues, this.namesAndValues);
+    }
+
+    public int hashCode() {
+        return Arrays.hashCode(this.namesAndValues);
+    }
+
+    public String toString() {
+        StringBuilder sb = new StringBuilder();
+        int size = size();
+        for (int i = 0; i < size; i++) {
+            sb.append(name(i));
+            sb.append(": ");
+            sb.append(value(i));
+            sb.append("\n");
+        }
+        return sb.toString();
+    }
+
+    public Map<String, List<String>> toMultimap() {
+        TreeMap treeMap = new TreeMap(String.CASE_INSENSITIVE_ORDER);
+        int size = size();
+        for (int i = 0; i < size; i++) {
+            String lowerCase = name(i).toLowerCase(Locale.US);
+            List list = (List) treeMap.get(lowerCase);
+            if (list == null) {
+                list = new ArrayList(2);
+                treeMap.put(lowerCase, list);
+            }
+            list.add(value(i));
+        }
+        return treeMap;
+    }
+
+    private static String get(String[] strArr, String str) {
+        for (int length = strArr.length - 2; length >= 0; length -= 2) {
+            if (str.equalsIgnoreCase(strArr[length])) {
+                return strArr[length + 1];
+            }
+        }
+        return null;
+    }
+
+    public static Headers of(String... strArr) {
+        if (strArr == null) {
+            throw new NullPointerException("namesAndValues == null");
+        }
+        if (strArr.length % 2 != 0) {
+            throw new IllegalArgumentException("Expected alternating header names and values");
+        }
+        String[] strArr2 = (String[]) strArr.clone();
+        for (int i = 0; i < strArr2.length; i++) {
+            String str = strArr2[i];
+            if (str == null) {
+                throw new IllegalArgumentException("Headers cannot be null");
+            }
+            strArr2[i] = str.trim();
+        }
+        for (int i2 = 0; i2 < strArr2.length; i2 += 2) {
+            String str2 = strArr2[i2];
+            String str3 = strArr2[i2 + 1];
+            checkName(str2);
+            checkValue(str3, str2);
+        }
+        return new Headers(strArr2);
+    }
+
+    public static Headers of(Map<String, String> map) {
+        if (map == null) {
+            throw new NullPointerException("headers == null");
+        }
+        String[] strArr = new String[map.size() * 2];
+        int i = 0;
+        for (Map.Entry<String, String> entry : map.entrySet()) {
+            if (entry.getKey() == null || entry.getValue() == null) {
+                throw new IllegalArgumentException("Headers cannot be null");
+            }
+            String trim = entry.getKey().trim();
+            String trim2 = entry.getValue().trim();
+            checkName(trim);
+            checkValue(trim2, trim);
+            strArr[i] = trim;
+            strArr[i + 1] = trim2;
+            i += 2;
+        }
+        return new Headers(strArr);
+    }
+
+    public static void checkName(String str) {
+        if (str == null) {
+            throw new NullPointerException("name == null");
+        }
+        if (str.isEmpty()) {
+            throw new IllegalArgumentException("name is empty");
+        }
+        int length = str.length();
+        for (int i = 0; i < length; i++) {
+            char charAt = str.charAt(i);
+            if (charAt <= ' ' || charAt >= 127) {
+                throw new IllegalArgumentException(Util.format("Unexpected char %#04x at %d in header name: %s", Integer.valueOf(charAt), Integer.valueOf(i), str));
+            }
+        }
+    }
+
+    public static void checkValue(String str, String str2) {
+        if (str == null) {
+            throw new NullPointerException("value for name " + str2 + " == null");
+        }
+        int length = str.length();
+        for (int i = 0; i < length; i++) {
+            char charAt = str.charAt(i);
+            if ((charAt <= 31 && charAt != '\t') || charAt >= 127) {
+                throw new IllegalArgumentException(Util.format("Unexpected char %#04x at %d in %s value: %s", Integer.valueOf(charAt), Integer.valueOf(i), str2, str));
+            }
+        }
+    }
+
+    public static final class Builder {
+        final List<String> namesAndValues = new ArrayList(20);
+
+        public Builder addLenient(String str) {
+            int indexOf = str.indexOf(CertificateUtil.DELIMITER, 1);
+            if (indexOf != -1) {
+                return addLenient(str.substring(0, indexOf), str.substring(indexOf + 1));
+            }
+            if (str.startsWith(CertificateUtil.DELIMITER)) {
+                return addLenient("", str.substring(1));
+            }
+            return addLenient("", str);
+        }
+
+        public Builder add(String str) {
+            int indexOf = str.indexOf(CertificateUtil.DELIMITER);
+            if (indexOf == -1) {
+                throw new IllegalArgumentException("Unexpected header: " + str);
+            }
+            return add(str.substring(0, indexOf).trim(), str.substring(indexOf + 1));
+        }
+
+        public Builder add(String str, String str2) {
+            Headers.checkName(str);
+            Headers.checkValue(str2, str);
+            return addLenient(str, str2);
+        }
+
+        public Builder addUnsafeNonAscii(String str, String str2) {
+            Headers.checkName(str);
+            return addLenient(str, str2);
+        }
+
+        public Builder addAll(Headers headers) {
+            int size = headers.size();
+            for (int i = 0; i < size; i++) {
+                addLenient(headers.name(i), headers.value(i));
+            }
+            return this;
+        }
+
+        public Builder add(String str, Date date) {
+            if (date == null) {
+                throw new NullPointerException("value for name " + str + " == null");
+            }
+            add(str, HttpDate.format(date));
+            return this;
+        }
+
+        public Builder set(String str, Date date) {
+            if (date == null) {
+                throw new NullPointerException("value for name " + str + " == null");
+            }
+            set(str, HttpDate.format(date));
+            return this;
+        }
+
+        public Builder addLenient(String str, String str2) {
+            this.namesAndValues.add(str);
+            this.namesAndValues.add(str2.trim());
+            return this;
+        }
+
+        public Builder removeAll(String str) {
+            int i = 0;
+            while (i < this.namesAndValues.size()) {
+                if (str.equalsIgnoreCase(this.namesAndValues.get(i))) {
+                    this.namesAndValues.remove(i);
+                    this.namesAndValues.remove(i);
+                    i -= 2;
+                }
+                i += 2;
+            }
+            return this;
+        }
+
+        public Builder set(String str, String str2) {
+            Headers.checkName(str);
+            Headers.checkValue(str2, str);
+            removeAll(str);
+            addLenient(str, str2);
+            return this;
+        }
+
+        public String get(String str) {
+            for (int size = this.namesAndValues.size() - 2; size >= 0; size -= 2) {
+                if (str.equalsIgnoreCase(this.namesAndValues.get(size))) {
+                    return this.namesAndValues.get(size + 1);
+                }
+            }
+            return null;
+        }
+
+        public Headers build() {
+            return new Headers(this);
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/thrid/okhttp/Interceptor.java

@@ -0,0 +1,32 @@
+package com.mbridge.msdk.thrid.okhttp;
+
+import java.io.IOException;
+import java.util.concurrent.TimeUnit;
+
+/* loaded from: classes4.dex */
+public interface Interceptor {
+
+    public interface Chain {
+        Call call();
+
+        int connectTimeoutMillis();
+
+        Connection connection();
+
+        Response proceed(Request request) throws IOException;
+
+        int readTimeoutMillis();
+
+        Request request();
+
+        Chain withConnectTimeout(int i, TimeUnit timeUnit);
+
+        Chain withReadTimeout(int i, TimeUnit timeUnit);
+
+        Chain withWriteTimeout(int i, TimeUnit timeUnit);
+
+        int writeTimeoutMillis();
+    }
+
+    Response intercept(Chain chain) throws IOException;
+}

decompiled/sources/com/mbridge/msdk/thrid/okhttp/MediaType.java

@@ -0,0 +1,102 @@
+package com.mbridge.msdk.thrid.okhttp;
+
+import com.ironsource.nb;
+import java.nio.charset.Charset;
+import java.util.Locale;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/* loaded from: classes4.dex */
+public final class MediaType {
+    private static final String QUOTED = "\"([^\"]*)\"";
+    private static final String TOKEN = "([a-zA-Z0-9-!#$%&'*+.^_`{|}~]+)";
+    private final String charset;
+    private final String mediaType;
+    private final String subtype;
+    private final String type;
+    private static final Pattern TYPE_SUBTYPE = Pattern.compile("([a-zA-Z0-9-!#$%&'*+.^_`{|}~]+)/([a-zA-Z0-9-!#$%&'*+.^_`{|}~]+)");
+    private static final Pattern PARAMETER = Pattern.compile(";\\s*(?:([a-zA-Z0-9-!#$%&'*+.^_`{|}~]+)=(?:([a-zA-Z0-9-!#$%&'*+.^_`{|}~]+)|\"([^\"]*)\"))?");
+
+    public String subtype() {
+        return this.subtype;
+    }
+
+    public String toString() {
+        return this.mediaType;
+    }
+
+    public String type() {
+        return this.type;
+    }
+
+    private MediaType(String str, String str2, String str3, String str4) {
+        this.mediaType = str;
+        this.type = str2;
+        this.subtype = str3;
+        this.charset = str4;
+    }
+
+    public static MediaType get(String str) {
+        Matcher matcher = TYPE_SUBTYPE.matcher(str);
+        if (!matcher.lookingAt()) {
+            throw new IllegalArgumentException("No subtype found for: \"" + str + '\"');
+        }
+        String group = matcher.group(1);
+        Locale locale = Locale.US;
+        String lowerCase = group.toLowerCase(locale);
+        String lowerCase2 = matcher.group(2).toLowerCase(locale);
+        Matcher matcher2 = PARAMETER.matcher(str);
+        String str2 = null;
+        for (int end = matcher.end(); end < str.length(); end = matcher2.end()) {
+            matcher2.region(end, str.length());
+            if (!matcher2.lookingAt()) {
+                throw new IllegalArgumentException("Parameter is not formatted correctly: \"" + str.substring(end) + "\" for: \"" + str + '\"');
+            }
+            String group2 = matcher2.group(1);
+            if (group2 != null && group2.equalsIgnoreCase(nb.M)) {
+                String group3 = matcher2.group(2);
+                if (group3 != null) {
+                    if (group3.startsWith("'") && group3.endsWith("'") && group3.length() > 2) {
+                        group3 = group3.substring(1, group3.length() - 1);
+                    }
+                } else {
+                    group3 = matcher2.group(3);
+                }
+                if (str2 != null && !group3.equalsIgnoreCase(str2)) {
+                    throw new IllegalArgumentException("Multiple charsets defined: \"" + str2 + "\" and: \"" + group3 + "\" for: \"" + str + '\"');
+                }
+                str2 = group3;
+            }
+        }
+        return new MediaType(str, lowerCase, lowerCase2, str2);
+    }
+
+    public static MediaType parse(String str) {
+        try {
+            return get(str);
+        } catch (IllegalArgumentException unused) {
+            return null;
+        }
+    }
+
+    public Charset charset() {
+        return charset(null);
+    }
+
+    public Charset charset(Charset charset) {
+        try {
+            String str = this.charset;
+            return str != null ? Charset.forName(str) : charset;
+        } catch (IllegalArgumentException unused) {
+            return charset;
+        }
+    }
+
+    public boolean equals(Object obj) {
+        return (obj instanceof MediaType) && ((MediaType) obj).mediaType.equals(this.mediaType);
+    }
+
+    public int hashCode() {
+        return this.mediaType.hashCode();
+    }
+}

decompiled/sources/com/mbridge/msdk/thrid/okhttp/MultipartBody.java

@@ -0,0 +1,265 @@
+package com.mbridge.msdk.thrid.okhttp;
+
+import androidx.browser.trusted.sharing.ShareTarget;
+import com.applovin.exoplayer2.common.base.Ascii;
+import com.mbridge.msdk.thrid.okhttp.Headers;
+import com.mbridge.msdk.thrid.okhttp.internal.Util;
+import com.mbridge.msdk.thrid.okio.Buffer;
+import com.mbridge.msdk.thrid.okio.BufferedSink;
+import com.mbridge.msdk.thrid.okio.ByteString;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.UUID;
+import org.apache.http.protocol.HTTP;
+
+/* loaded from: classes4.dex */
+public final class MultipartBody extends RequestBody {
+    private final ByteString boundary;
+    private long contentLength = -1;
+    private final MediaType contentType;
+    private final MediaType originalType;
+    private final List<Part> parts;
+    public static final MediaType MIXED = MediaType.get("multipart/mixed");
+    public static final MediaType ALTERNATIVE = MediaType.get("multipart/alternative");
+    public static final MediaType DIGEST = MediaType.get("multipart/digest");
+    public static final MediaType PARALLEL = MediaType.get("multipart/parallel");
+    public static final MediaType FORM = MediaType.get(ShareTarget.ENCODING_TYPE_MULTIPART);
+    private static final byte[] COLONSPACE = {58, 32};
+    private static final byte[] CRLF = {Ascii.CR, 10};
+    private static final byte[] DASHDASH = {45, 45};
+
+    @Override // com.mbridge.msdk.thrid.okhttp.RequestBody
+    public MediaType contentType() {
+        return this.contentType;
+    }
+
+    public List<Part> parts() {
+        return this.parts;
+    }
+
+    public MediaType type() {
+        return this.originalType;
+    }
+
+    public MultipartBody(ByteString byteString, MediaType mediaType, List<Part> list) {
+        this.boundary = byteString;
+        this.originalType = mediaType;
+        this.contentType = MediaType.get(mediaType + "; boundary=" + byteString.utf8());
+        this.parts = Util.immutableList(list);
+    }
+
+    public String boundary() {
+        return this.boundary.utf8();
+    }
+
+    public int size() {
+        return this.parts.size();
+    }
+
+    public Part part(int i) {
+        return this.parts.get(i);
+    }
+
+    @Override // com.mbridge.msdk.thrid.okhttp.RequestBody
+    public long contentLength() throws IOException {
+        long j = this.contentLength;
+        if (j != -1) {
+            return j;
+        }
+        long writeOrCountBytes = writeOrCountBytes(null, true);
+        this.contentLength = writeOrCountBytes;
+        return writeOrCountBytes;
+    }
+
+    @Override // com.mbridge.msdk.thrid.okhttp.RequestBody
+    public void writeTo(BufferedSink bufferedSink) throws IOException {
+        writeOrCountBytes(bufferedSink, false);
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    private long writeOrCountBytes(BufferedSink bufferedSink, boolean z) throws IOException {
+        Buffer buffer;
+        if (z) {
+            bufferedSink = new Buffer();
+            buffer = bufferedSink;
+        } else {
+            buffer = 0;
+        }
+        int size = this.parts.size();
+        long j = 0;
+        for (int i = 0; i < size; i++) {
+            Part part = this.parts.get(i);
+            Headers headers = part.headers;
+            RequestBody requestBody = part.body;
+            bufferedSink.write(DASHDASH);
+            bufferedSink.write(this.boundary);
+            bufferedSink.write(CRLF);
+            if (headers != null) {
+                int size2 = headers.size();
+                for (int i2 = 0; i2 < size2; i2++) {
+                    bufferedSink.writeUtf8(headers.name(i2)).write(COLONSPACE).writeUtf8(headers.value(i2)).write(CRLF);
+                }
+            }
+            MediaType contentType = requestBody.contentType();
+            if (contentType != null) {
+                bufferedSink.writeUtf8("Content-Type: ").writeUtf8(contentType.toString()).write(CRLF);
+            }
+            long contentLength = requestBody.contentLength();
+            if (contentLength != -1) {
+                bufferedSink.writeUtf8("Content-Length: ").writeDecimalLong(contentLength).write(CRLF);
+            } else if (z) {
+                buffer.clear();
+                return -1L;
+            }
+            byte[] bArr = CRLF;
+            bufferedSink.write(bArr);
+            if (z) {
+                j += contentLength;
+            } else {
+                requestBody.writeTo(bufferedSink);
+            }
+            bufferedSink.write(bArr);
+        }
+        byte[] bArr2 = DASHDASH;
+        bufferedSink.write(bArr2);
+        bufferedSink.write(this.boundary);
+        bufferedSink.write(bArr2);
+        bufferedSink.write(CRLF);
+        if (!z) {
+            return j;
+        }
+        long size3 = j + buffer.size();
+        buffer.clear();
+        return size3;
+    }
+
+    public static StringBuilder appendQuotedString(StringBuilder sb, String str) {
+        sb.append('\"');
+        int length = str.length();
+        for (int i = 0; i < length; i++) {
+            char charAt = str.charAt(i);
+            if (charAt == '\n') {
+                sb.append("%0A");
+            } else if (charAt == '\r') {
+                sb.append("%0D");
+            } else if (charAt == '\"') {
+                sb.append("%22");
+            } else {
+                sb.append(charAt);
+            }
+        }
+        sb.append('\"');
+        return sb;
+    }
+
+    public static final class Part {
+        final RequestBody body;
+        final Headers headers;
+
+        public RequestBody body() {
+            return this.body;
+        }
+
+        public Headers headers() {
+            return this.headers;
+        }
+
+        public static Part create(RequestBody requestBody) {
+            return create(null, requestBody);
+        }
+
+        public static Part create(Headers headers, RequestBody requestBody) {
+            if (requestBody == null) {
+                throw new NullPointerException("body == null");
+            }
+            if (headers != null && headers.get("Content-Type") != null) {
+                throw new IllegalArgumentException("Unexpected header: Content-Type");
+            }
+            if (headers != null && headers.get(HTTP.CONTENT_LEN) != null) {
+                throw new IllegalArgumentException("Unexpected header: Content-Length");
+            }
+            return new Part(headers, requestBody);
+        }
+
+        public static Part createFormData(String str, String str2) {
+            return createFormData(str, null, RequestBody.create((MediaType) null, str2));
+        }
+
+        public static Part createFormData(String str, String str2, RequestBody requestBody) {
+            if (str == null) {
+                throw new NullPointerException("name == null");
+            }
+            StringBuilder sb = new StringBuilder("form-data; name=");
+            MultipartBody.appendQuotedString(sb, str);
+            if (str2 != null) {
+                sb.append("; filename=");
+                MultipartBody.appendQuotedString(sb, str2);
+            }
+            return create(new Headers.Builder().addUnsafeNonAscii("Content-Disposition", sb.toString()).build(), requestBody);
+        }
+
+        private Part(Headers headers, RequestBody requestBody) {
+            this.headers = headers;
+            this.body = requestBody;
+        }
+    }
+
+    public static final class Builder {
+        private final ByteString boundary;
+        private final List<Part> parts;
+        private MediaType type;
+
+        public Builder() {
+            this(UUID.randomUUID().toString());
+        }
+
+        public Builder(String str) {
+            this.type = MultipartBody.MIXED;
+            this.parts = new ArrayList();
+            this.boundary = ByteString.encodeUtf8(str);
+        }
+
+        public Builder setType(MediaType mediaType) {
+            if (mediaType == null) {
+                throw new NullPointerException("type == null");
+            }
+            if (mediaType.type().equals("multipart")) {
+                this.type = mediaType;
+                return this;
+            }
+            throw new IllegalArgumentException("multipart != " + mediaType);
+        }
+
+        public Builder addPart(RequestBody requestBody) {
+            return addPart(Part.create(requestBody));
+        }
+
+        public Builder addPart(Headers headers, RequestBody requestBody) {
+            return addPart(Part.create(headers, requestBody));
+        }
+
+        public Builder addFormDataPart(String str, String str2) {
+            return addPart(Part.createFormData(str, str2));
+        }
+
+        public Builder addFormDataPart(String str, String str2, RequestBody requestBody) {
+            return addPart(Part.createFormData(str, str2, requestBody));
+        }
+
+        public Builder addPart(Part part) {
+            if (part == null) {
+                throw new NullPointerException("part == null");
+            }
+            this.parts.add(part);
+            return this;
+        }
+
+        public MultipartBody build() {
+            if (this.parts.isEmpty()) {
+                throw new IllegalStateException("Multipart body must have at least one part.");
+            }
+            return new MultipartBody(this.boundary, this.type, this.parts);
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/thrid/okhttp/OkHttpClient.java

@@ -0,0 +1,693 @@
+package com.mbridge.msdk.thrid.okhttp;
+
+import com.mbridge.msdk.thrid.okhttp.Call;
+import com.mbridge.msdk.thrid.okhttp.EventListener;
+import com.mbridge.msdk.thrid.okhttp.Headers;
+import com.mbridge.msdk.thrid.okhttp.Response;
+import com.mbridge.msdk.thrid.okhttp.WebSocket;
+import com.mbridge.msdk.thrid.okhttp.internal.Internal;
+import com.mbridge.msdk.thrid.okhttp.internal.Util;
+import com.mbridge.msdk.thrid.okhttp.internal.cache.InternalCache;
+import com.mbridge.msdk.thrid.okhttp.internal.connection.RealConnection;
+import com.mbridge.msdk.thrid.okhttp.internal.connection.RouteDatabase;
+import com.mbridge.msdk.thrid.okhttp.internal.connection.StreamAllocation;
+import com.mbridge.msdk.thrid.okhttp.internal.platform.Platform;
+import com.mbridge.msdk.thrid.okhttp.internal.proxy.NullProxySelector;
+import com.mbridge.msdk.thrid.okhttp.internal.tls.CertificateChainCleaner;
+import com.mbridge.msdk.thrid.okhttp.internal.tls.OkHostnameVerifier;
+import com.mbridge.msdk.thrid.okhttp.internal.ws.RealWebSocket;
+import java.io.IOException;
+import java.net.Proxy;
+import java.net.ProxySelector;
+import java.net.Socket;
+import java.security.GeneralSecurityException;
+import java.time.Duration;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Random;
+import java.util.concurrent.TimeUnit;
+import javax.net.SocketFactory;
+import javax.net.ssl.HostnameVerifier;
+import javax.net.ssl.SSLContext;
+import javax.net.ssl.SSLSocket;
+import javax.net.ssl.SSLSocketFactory;
+import javax.net.ssl.TrustManager;
+import javax.net.ssl.X509TrustManager;
+
+/* loaded from: classes4.dex */
+public class OkHttpClient implements Cloneable, Call.Factory, WebSocket.Factory {
+    final Authenticator authenticator;
+    final Cache cache;
+    final int callTimeout;
+    final CertificateChainCleaner certificateChainCleaner;
+    final CertificatePinner certificatePinner;
+    final int connectTimeout;
+    final ConnectionPool connectionPool;
+    final List<ConnectionSpec> connectionSpecs;
+    final CookieJar cookieJar;
+    final Dispatcher dispatcher;
+    final Dns dns;
+    final EventListener.Factory eventListenerFactory;
+    final boolean followRedirects;
+    final boolean followSslRedirects;
+    final HostnameVerifier hostnameVerifier;
+    final List<Interceptor> interceptors;
+    final InternalCache internalCache;
+    final List<Interceptor> networkInterceptors;
+    final int pingInterval;
+    final List<Protocol> protocols;
+    final Proxy proxy;
+    final Authenticator proxyAuthenticator;
+    final ProxySelector proxySelector;
+    final int readTimeout;
+    final boolean retryOnConnectionFailure;
+    final SocketFactory socketFactory;
+    final SSLSocketFactory sslSocketFactory;
+    final int writeTimeout;
+    static final List<Protocol> DEFAULT_PROTOCOLS = Util.immutableList(Protocol.HTTP_2, Protocol.HTTP_1_1);
+    static final List<ConnectionSpec> DEFAULT_CONNECTION_SPECS = Util.immutableList(ConnectionSpec.MODERN_TLS, ConnectionSpec.CLEARTEXT);
+
+    public Authenticator authenticator() {
+        return this.authenticator;
+    }
+
+    public Cache cache() {
+        return this.cache;
+    }
+
+    public int callTimeoutMillis() {
+        return this.callTimeout;
+    }
+
+    public CertificatePinner certificatePinner() {
+        return this.certificatePinner;
+    }
+
+    public int connectTimeoutMillis() {
+        return this.connectTimeout;
+    }
+
+    public ConnectionPool connectionPool() {
+        return this.connectionPool;
+    }
+
+    public List<ConnectionSpec> connectionSpecs() {
+        return this.connectionSpecs;
+    }
+
+    public CookieJar cookieJar() {
+        return this.cookieJar;
+    }
+
+    public Dispatcher dispatcher() {
+        return this.dispatcher;
+    }
+
+    public Dns dns() {
+        return this.dns;
+    }
+
+    public EventListener.Factory eventListenerFactory() {
+        return this.eventListenerFactory;
+    }
+
+    public boolean followRedirects() {
+        return this.followRedirects;
+    }
+
+    public boolean followSslRedirects() {
+        return this.followSslRedirects;
+    }
+
+    public HostnameVerifier hostnameVerifier() {
+        return this.hostnameVerifier;
+    }
+
+    public List<Interceptor> interceptors() {
+        return this.interceptors;
+    }
+
+    public List<Interceptor> networkInterceptors() {
+        return this.networkInterceptors;
+    }
+
+    public int pingIntervalMillis() {
+        return this.pingInterval;
+    }
+
+    public List<Protocol> protocols() {
+        return this.protocols;
+    }
+
+    public Proxy proxy() {
+        return this.proxy;
+    }
+
+    public Authenticator proxyAuthenticator() {
+        return this.proxyAuthenticator;
+    }
+
+    public ProxySelector proxySelector() {
+        return this.proxySelector;
+    }
+
+    public int readTimeoutMillis() {
+        return this.readTimeout;
+    }
+
+    public boolean retryOnConnectionFailure() {
+        return this.retryOnConnectionFailure;
+    }
+
+    public SocketFactory socketFactory() {
+        return this.socketFactory;
+    }
+
+    public SSLSocketFactory sslSocketFactory() {
+        return this.sslSocketFactory;
+    }
+
+    public int writeTimeoutMillis() {
+        return this.writeTimeout;
+    }
+
+    static {
+        Internal.instance = new Internal() { // from class: com.mbridge.msdk.thrid.okhttp.OkHttpClient.1
+            @Override // com.mbridge.msdk.thrid.okhttp.internal.Internal
+            public void addLenient(Headers.Builder builder, String str) {
+                builder.addLenient(str);
+            }
+
+            @Override // com.mbridge.msdk.thrid.okhttp.internal.Internal
+            public void addLenient(Headers.Builder builder, String str, String str2) {
+                builder.addLenient(str, str2);
+            }
+
+            @Override // com.mbridge.msdk.thrid.okhttp.internal.Internal
+            public void setCache(Builder builder, InternalCache internalCache) {
+                builder.setInternalCache(internalCache);
+            }
+
+            @Override // com.mbridge.msdk.thrid.okhttp.internal.Internal
+            public boolean connectionBecameIdle(ConnectionPool connectionPool, RealConnection realConnection) {
+                return connectionPool.connectionBecameIdle(realConnection);
+            }
+
+            @Override // com.mbridge.msdk.thrid.okhttp.internal.Internal
+            public RealConnection get(ConnectionPool connectionPool, Address address, StreamAllocation streamAllocation, Route route) {
+                return connectionPool.get(address, streamAllocation, route);
+            }
+
+            @Override // com.mbridge.msdk.thrid.okhttp.internal.Internal
+            public boolean equalsNonHost(Address address, Address address2) {
+                return address.equalsNonHost(address2);
+            }
+
+            @Override // com.mbridge.msdk.thrid.okhttp.internal.Internal
+            public Socket deduplicate(ConnectionPool connectionPool, Address address, StreamAllocation streamAllocation) {
+                return connectionPool.deduplicate(address, streamAllocation);
+            }
+
+            @Override // com.mbridge.msdk.thrid.okhttp.internal.Internal
+            public void put(ConnectionPool connectionPool, RealConnection realConnection) {
+                connectionPool.put(realConnection);
+            }
+
+            @Override // com.mbridge.msdk.thrid.okhttp.internal.Internal
+            public RouteDatabase routeDatabase(ConnectionPool connectionPool) {
+                return connectionPool.routeDatabase;
+            }
+
+            @Override // com.mbridge.msdk.thrid.okhttp.internal.Internal
+            public int code(Response.Builder builder) {
+                return builder.code;
+            }
+
+            @Override // com.mbridge.msdk.thrid.okhttp.internal.Internal
+            public void apply(ConnectionSpec connectionSpec, SSLSocket sSLSocket, boolean z) {
+                connectionSpec.apply(sSLSocket, z);
+            }
+
+            @Override // com.mbridge.msdk.thrid.okhttp.internal.Internal
+            public boolean isInvalidHttpUrlHost(IllegalArgumentException illegalArgumentException) {
+                return illegalArgumentException.getMessage().startsWith("Invalid URL host");
+            }
+
+            @Override // com.mbridge.msdk.thrid.okhttp.internal.Internal
+            public StreamAllocation streamAllocation(Call call) {
+                return ((RealCall) call).streamAllocation();
+            }
+
+            @Override // com.mbridge.msdk.thrid.okhttp.internal.Internal
+            public IOException timeoutExit(Call call, IOException iOException) {
+                return ((RealCall) call).timeoutExit(iOException);
+            }
+
+            @Override // com.mbridge.msdk.thrid.okhttp.internal.Internal
+            public Call newWebSocketCall(OkHttpClient okHttpClient, Request request) {
+                return RealCall.newRealCall(okHttpClient, request, true);
+            }
+        };
+    }
+
+    public OkHttpClient() {
+        this(new Builder());
+    }
+
+    public OkHttpClient(Builder builder) {
+        boolean z;
+        this.dispatcher = builder.dispatcher;
+        this.proxy = builder.proxy;
+        this.protocols = builder.protocols;
+        List<ConnectionSpec> list = builder.connectionSpecs;
+        this.connectionSpecs = list;
+        this.interceptors = Util.immutableList(builder.interceptors);
+        this.networkInterceptors = Util.immutableList(builder.networkInterceptors);
+        this.eventListenerFactory = builder.eventListenerFactory;
+        this.proxySelector = builder.proxySelector;
+        this.cookieJar = builder.cookieJar;
+        this.cache = builder.cache;
+        this.internalCache = builder.internalCache;
+        this.socketFactory = builder.socketFactory;
+        Iterator<ConnectionSpec> it = list.iterator();
+        loop0: while (true) {
+            z = false;
+            while (it.hasNext()) {
+                z = (z || it.next().isTls()) ? true : z;
+            }
+        }
+        SSLSocketFactory sSLSocketFactory = builder.sslSocketFactory;
+        if (sSLSocketFactory != null || !z) {
+            this.sslSocketFactory = sSLSocketFactory;
+            this.certificateChainCleaner = builder.certificateChainCleaner;
+        } else {
+            X509TrustManager platformTrustManager = Util.platformTrustManager();
+            this.sslSocketFactory = newSslSocketFactory(platformTrustManager);
+            this.certificateChainCleaner = CertificateChainCleaner.get(platformTrustManager);
+        }
+        if (this.sslSocketFactory != null) {
+            Platform.get().configureSslSocketFactory(this.sslSocketFactory);
+        }
+        this.hostnameVerifier = builder.hostnameVerifier;
+        this.certificatePinner = builder.certificatePinner.withCertificateChainCleaner(this.certificateChainCleaner);
+        this.proxyAuthenticator = builder.proxyAuthenticator;
+        this.authenticator = builder.authenticator;
+        this.connectionPool = builder.connectionPool;
+        this.dns = builder.dns;
+        this.followSslRedirects = builder.followSslRedirects;
+        this.followRedirects = builder.followRedirects;
+        this.retryOnConnectionFailure = builder.retryOnConnectionFailure;
+        this.callTimeout = builder.callTimeout;
+        this.connectTimeout = builder.connectTimeout;
+        this.readTimeout = builder.readTimeout;
+        this.writeTimeout = builder.writeTimeout;
+        this.pingInterval = builder.pingInterval;
+        if (this.interceptors.contains(null)) {
+            throw new IllegalStateException("Null interceptor: " + this.interceptors);
+        }
+        if (this.networkInterceptors.contains(null)) {
+            throw new IllegalStateException("Null network interceptor: " + this.networkInterceptors);
+        }
+    }
+
+    private static SSLSocketFactory newSslSocketFactory(X509TrustManager x509TrustManager) {
+        try {
+            SSLContext sSLContext = Platform.get().getSSLContext();
+            sSLContext.init(null, new TrustManager[]{x509TrustManager}, null);
+            return sSLContext.getSocketFactory();
+        } catch (GeneralSecurityException e) {
+            throw Util.assertionError("No System TLS", e);
+        }
+    }
+
+    public InternalCache internalCache() {
+        Cache cache = this.cache;
+        return cache != null ? cache.internalCache : this.internalCache;
+    }
+
+    @Override // com.mbridge.msdk.thrid.okhttp.Call.Factory
+    public Call newCall(Request request) {
+        return RealCall.newRealCall(this, request, false);
+    }
+
+    @Override // com.mbridge.msdk.thrid.okhttp.WebSocket.Factory
+    public WebSocket newWebSocket(Request request, WebSocketListener webSocketListener) {
+        RealWebSocket realWebSocket = new RealWebSocket(request, webSocketListener, new Random(), this.pingInterval);
+        realWebSocket.connect(this);
+        return realWebSocket;
+    }
+
+    public Builder newBuilder() {
+        return new Builder(this);
+    }
+
+    public static final class Builder {
+        Authenticator authenticator;
+        Cache cache;
+        int callTimeout;
+        CertificateChainCleaner certificateChainCleaner;
+        CertificatePinner certificatePinner;
+        int connectTimeout;
+        ConnectionPool connectionPool;
+        List<ConnectionSpec> connectionSpecs;
+        CookieJar cookieJar;
+        Dispatcher dispatcher;
+        Dns dns;
+        EventListener.Factory eventListenerFactory;
+        boolean followRedirects;
+        boolean followSslRedirects;
+        HostnameVerifier hostnameVerifier;
+        final List<Interceptor> interceptors;
+        InternalCache internalCache;
+        final List<Interceptor> networkInterceptors;
+        int pingInterval;
+        List<Protocol> protocols;
+        Proxy proxy;
+        Authenticator proxyAuthenticator;
+        ProxySelector proxySelector;
+        int readTimeout;
+        boolean retryOnConnectionFailure;
+        SocketFactory socketFactory;
+        SSLSocketFactory sslSocketFactory;
+        int writeTimeout;
+
+        public Builder cache(Cache cache) {
+            this.cache = cache;
+            this.internalCache = null;
+            return this;
+        }
+
+        public Builder followRedirects(boolean z) {
+            this.followRedirects = z;
+            return this;
+        }
+
+        public Builder followSslRedirects(boolean z) {
+            this.followSslRedirects = z;
+            return this;
+        }
+
+        public List<Interceptor> interceptors() {
+            return this.interceptors;
+        }
+
+        public List<Interceptor> networkInterceptors() {
+            return this.networkInterceptors;
+        }
+
+        public Builder proxy(Proxy proxy) {
+            this.proxy = proxy;
+            return this;
+        }
+
+        public Builder retryOnConnectionFailure(boolean z) {
+            this.retryOnConnectionFailure = z;
+            return this;
+        }
+
+        public void setInternalCache(InternalCache internalCache) {
+            this.internalCache = internalCache;
+            this.cache = null;
+        }
+
+        public Builder() {
+            this.interceptors = new ArrayList();
+            this.networkInterceptors = new ArrayList();
+            this.dispatcher = new Dispatcher();
+            this.protocols = OkHttpClient.DEFAULT_PROTOCOLS;
+            this.connectionSpecs = OkHttpClient.DEFAULT_CONNECTION_SPECS;
+            this.eventListenerFactory = EventListener.factory(EventListener.NONE);
+            ProxySelector proxySelector = ProxySelector.getDefault();
+            this.proxySelector = proxySelector;
+            if (proxySelector == null) {
+                this.proxySelector = new NullProxySelector();
+            }
+            this.cookieJar = CookieJar.NO_COOKIES;
+            this.socketFactory = SocketFactory.getDefault();
+            this.hostnameVerifier = OkHostnameVerifier.INSTANCE;
+            this.certificatePinner = CertificatePinner.DEFAULT;
+            Authenticator authenticator = Authenticator.NONE;
+            this.proxyAuthenticator = authenticator;
+            this.authenticator = authenticator;
+            this.connectionPool = new ConnectionPool();
+            this.dns = Dns.SYSTEM;
+            this.followSslRedirects = true;
+            this.followRedirects = true;
+            this.retryOnConnectionFailure = true;
+            this.callTimeout = 0;
+            this.connectTimeout = 10000;
+            this.readTimeout = 10000;
+            this.writeTimeout = 10000;
+            this.pingInterval = 0;
+        }
+
+        public Builder(OkHttpClient okHttpClient) {
+            ArrayList arrayList = new ArrayList();
+            this.interceptors = arrayList;
+            ArrayList arrayList2 = new ArrayList();
+            this.networkInterceptors = arrayList2;
+            this.dispatcher = okHttpClient.dispatcher;
+            this.proxy = okHttpClient.proxy;
+            this.protocols = okHttpClient.protocols;
+            this.connectionSpecs = okHttpClient.connectionSpecs;
+            arrayList.addAll(okHttpClient.interceptors);
+            arrayList2.addAll(okHttpClient.networkInterceptors);
+            this.eventListenerFactory = okHttpClient.eventListenerFactory;
+            this.proxySelector = okHttpClient.proxySelector;
+            this.cookieJar = okHttpClient.cookieJar;
+            this.internalCache = okHttpClient.internalCache;
+            this.cache = okHttpClient.cache;
+            this.socketFactory = okHttpClient.socketFactory;
+            this.sslSocketFactory = okHttpClient.sslSocketFactory;
+            this.certificateChainCleaner = okHttpClient.certificateChainCleaner;
+            this.hostnameVerifier = okHttpClient.hostnameVerifier;
+            this.certificatePinner = okHttpClient.certificatePinner;
+            this.proxyAuthenticator = okHttpClient.proxyAuthenticator;
+            this.authenticator = okHttpClient.authenticator;
+            this.connectionPool = okHttpClient.connectionPool;
+            this.dns = okHttpClient.dns;
+            this.followSslRedirects = okHttpClient.followSslRedirects;
+            this.followRedirects = okHttpClient.followRedirects;
+            this.retryOnConnectionFailure = okHttpClient.retryOnConnectionFailure;
+            this.callTimeout = okHttpClient.callTimeout;
+            this.connectTimeout = okHttpClient.connectTimeout;
+            this.readTimeout = okHttpClient.readTimeout;
+            this.writeTimeout = okHttpClient.writeTimeout;
+            this.pingInterval = okHttpClient.pingInterval;
+        }
+
+        public Builder callTimeout(long j, TimeUnit timeUnit) {
+            this.callTimeout = Util.checkDuration("timeout", j, timeUnit);
+            return this;
+        }
+
+        public Builder callTimeout(Duration duration) {
+            this.callTimeout = Util.checkDuration("timeout", duration.toMillis(), TimeUnit.MILLISECONDS);
+            return this;
+        }
+
+        public Builder connectTimeout(long j, TimeUnit timeUnit) {
+            this.connectTimeout = Util.checkDuration("timeout", j, timeUnit);
+            return this;
+        }
+
+        public Builder connectTimeout(Duration duration) {
+            this.connectTimeout = Util.checkDuration("timeout", duration.toMillis(), TimeUnit.MILLISECONDS);
+            return this;
+        }
+
+        public Builder readTimeout(long j, TimeUnit timeUnit) {
+            this.readTimeout = Util.checkDuration("timeout", j, timeUnit);
+            return this;
+        }
+
+        public Builder readTimeout(Duration duration) {
+            this.readTimeout = Util.checkDuration("timeout", duration.toMillis(), TimeUnit.MILLISECONDS);
+            return this;
+        }
+
+        public Builder writeTimeout(long j, TimeUnit timeUnit) {
+            this.writeTimeout = Util.checkDuration("timeout", j, timeUnit);
+            return this;
+        }
+
+        public Builder writeTimeout(Duration duration) {
+            this.writeTimeout = Util.checkDuration("timeout", duration.toMillis(), TimeUnit.MILLISECONDS);
+            return this;
+        }
+
+        public Builder pingInterval(long j, TimeUnit timeUnit) {
+            this.pingInterval = Util.checkDuration("interval", j, timeUnit);
+            return this;
+        }
+
+        public Builder pingInterval(Duration duration) {
+            this.pingInterval = Util.checkDuration("timeout", duration.toMillis(), TimeUnit.MILLISECONDS);
+            return this;
+        }
+
+        public Builder proxySelector(ProxySelector proxySelector) {
+            if (proxySelector == null) {
+                throw new NullPointerException("proxySelector == null");
+            }
+            this.proxySelector = proxySelector;
+            return this;
+        }
+
+        public Builder cookieJar(CookieJar cookieJar) {
+            if (cookieJar == null) {
+                throw new NullPointerException("cookieJar == null");
+            }
+            this.cookieJar = cookieJar;
+            return this;
+        }
+
+        public Builder dns(Dns dns) {
+            if (dns == null) {
+                throw new NullPointerException("dns == null");
+            }
+            this.dns = dns;
+            return this;
+        }
+
+        public Builder socketFactory(SocketFactory socketFactory) {
+            if (socketFactory == null) {
+                throw new NullPointerException("socketFactory == null");
+            }
+            this.socketFactory = socketFactory;
+            return this;
+        }
+
+        public Builder sslSocketFactory(SSLSocketFactory sSLSocketFactory) {
+            if (sSLSocketFactory == null) {
+                throw new NullPointerException("sslSocketFactory == null");
+            }
+            this.sslSocketFactory = sSLSocketFactory;
+            this.certificateChainCleaner = Platform.get().buildCertificateChainCleaner(sSLSocketFactory);
+            return this;
+        }
+
+        public Builder sslSocketFactory(SSLSocketFactory sSLSocketFactory, X509TrustManager x509TrustManager) {
+            if (sSLSocketFactory == null) {
+                throw new NullPointerException("sslSocketFactory == null");
+            }
+            if (x509TrustManager == null) {
+                throw new NullPointerException("trustManager == null");
+            }
+            this.sslSocketFactory = sSLSocketFactory;
+            this.certificateChainCleaner = CertificateChainCleaner.get(x509TrustManager);
+            return this;
+        }
+
+        public Builder hostnameVerifier(HostnameVerifier hostnameVerifier) {
+            if (hostnameVerifier == null) {
+                throw new NullPointerException("hostnameVerifier == null");
+            }
+            this.hostnameVerifier = hostnameVerifier;
+            return this;
+        }
+
+        public Builder certificatePinner(CertificatePinner certificatePinner) {
+            if (certificatePinner == null) {
+                throw new NullPointerException("certificatePinner == null");
+            }
+            this.certificatePinner = certificatePinner;
+            return this;
+        }
+
+        public Builder authenticator(Authenticator authenticator) {
+            if (authenticator == null) {
+                throw new NullPointerException("authenticator == null");
+            }
+            this.authenticator = authenticator;
+            return this;
+        }
+
+        public Builder proxyAuthenticator(Authenticator authenticator) {
+            if (authenticator == null) {
+                throw new NullPointerException("proxyAuthenticator == null");
+            }
+            this.proxyAuthenticator = authenticator;
+            return this;
+        }
+
+        public Builder connectionPool(ConnectionPool connectionPool) {
+            if (connectionPool == null) {
+                throw new NullPointerException("connectionPool == null");
+            }
+            this.connectionPool = connectionPool;
+            return this;
+        }
+
+        public Builder dispatcher(Dispatcher dispatcher) {
+            if (dispatcher == null) {
+                throw new IllegalArgumentException("dispatcher == null");
+            }
+            this.dispatcher = dispatcher;
+            return this;
+        }
+
+        public Builder protocols(List<Protocol> list) {
+            ArrayList arrayList = new ArrayList(list);
+            Protocol protocol = Protocol.H2_PRIOR_KNOWLEDGE;
+            if (!arrayList.contains(protocol) && !arrayList.contains(Protocol.HTTP_1_1)) {
+                throw new IllegalArgumentException("protocols must contain h2_prior_knowledge or http/1.1: " + arrayList);
+            }
+            if (arrayList.contains(protocol) && arrayList.size() > 1) {
+                throw new IllegalArgumentException("protocols containing h2_prior_knowledge cannot use other protocols: " + arrayList);
+            }
+            if (arrayList.contains(Protocol.HTTP_1_0)) {
+                throw new IllegalArgumentException("protocols must not contain http/1.0: " + arrayList);
+            }
+            if (arrayList.contains(null)) {
+                throw new IllegalArgumentException("protocols must not contain null");
+            }
+            arrayList.remove(Protocol.SPDY_3);
+            this.protocols = Collections.unmodifiableList(arrayList);
+            return this;
+        }
+
+        public Builder connectionSpecs(List<ConnectionSpec> list) {
+            this.connectionSpecs = Util.immutableList(list);
+            return this;
+        }
+
+        public Builder addInterceptor(Interceptor interceptor) {
+            if (interceptor == null) {
+                throw new IllegalArgumentException("interceptor == null");
+            }
+            this.interceptors.add(interceptor);
+            return this;
+        }
+
+        public Builder addNetworkInterceptor(Interceptor interceptor) {
+            if (interceptor == null) {
+                throw new IllegalArgumentException("interceptor == null");
+            }
+            this.networkInterceptors.add(interceptor);
+            return this;
+        }
+
+        public Builder eventListener(EventListener eventListener) {
+            if (eventListener == null) {
+                throw new NullPointerException("eventListener == null");
+            }
+            this.eventListenerFactory = EventListener.factory(eventListener);
+            return this;
+        }
+
+        public Builder eventListenerFactory(EventListener.Factory factory) {
+            if (factory == null) {
+                throw new NullPointerException("eventListenerFactory == null");
+            }
+            this.eventListenerFactory = factory;
+            return this;
+        }
+
+        public OkHttpClient build() {
+            return new OkHttpClient(this);
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/thrid/okhttp/Protocol.java

@@ -0,0 +1,52 @@
+package com.mbridge.msdk.thrid.okhttp;
+
+import java.io.IOException;
+
+/* loaded from: classes4.dex */
+public enum Protocol {
+    HTTP_1_0("http/1.0"),
+    HTTP_1_1("http/1.1"),
+    SPDY_3("spdy/3.1"),
+    HTTP_2("h2"),
+    H2_PRIOR_KNOWLEDGE("h2_prior_knowledge"),
+    QUIC("quic");
+
+    private final String protocol;
+
+    @Override // java.lang.Enum
+    public String toString() {
+        return this.protocol;
+    }
+
+    Protocol(String str) {
+        this.protocol = str;
+    }
+
+    public static Protocol get(String str) throws IOException {
+        Protocol protocol = HTTP_1_0;
+        if (str.equals(protocol.protocol)) {
+            return protocol;
+        }
+        Protocol protocol2 = HTTP_1_1;
+        if (str.equals(protocol2.protocol)) {
+            return protocol2;
+        }
+        Protocol protocol3 = H2_PRIOR_KNOWLEDGE;
+        if (str.equals(protocol3.protocol)) {
+            return protocol3;
+        }
+        Protocol protocol4 = HTTP_2;
+        if (str.equals(protocol4.protocol)) {
+            return protocol4;
+        }
+        Protocol protocol5 = SPDY_3;
+        if (str.equals(protocol5.protocol)) {
+            return protocol5;
+        }
+        Protocol protocol6 = QUIC;
+        if (str.equals(protocol6.protocol)) {
+            return protocol6;
+        }
+        throw new IOException("Unexpected protocol: " + str);
+    }
+}

decompiled/sources/com/mbridge/msdk/thrid/okhttp/RealCall.java

@@ -0,0 +1,259 @@
+package com.mbridge.msdk.thrid.okhttp;
+
+import androidx.core.app.NotificationCompat;
+import com.mbridge.msdk.thrid.okhttp.internal.NamedRunnable;
+import com.mbridge.msdk.thrid.okhttp.internal.Util;
+import com.mbridge.msdk.thrid.okhttp.internal.cache.CacheInterceptor;
+import com.mbridge.msdk.thrid.okhttp.internal.connection.ConnectInterceptor;
+import com.mbridge.msdk.thrid.okhttp.internal.connection.StreamAllocation;
+import com.mbridge.msdk.thrid.okhttp.internal.http.BridgeInterceptor;
+import com.mbridge.msdk.thrid.okhttp.internal.http.CallServerInterceptor;
+import com.mbridge.msdk.thrid.okhttp.internal.http.RealInterceptorChain;
+import com.mbridge.msdk.thrid.okhttp.internal.http.RetryAndFollowUpInterceptor;
+import com.mbridge.msdk.thrid.okhttp.internal.platform.Platform;
+import com.mbridge.msdk.thrid.okio.AsyncTimeout;
+import com.mbridge.msdk.thrid.okio.Timeout;
+import java.io.IOException;
+import java.io.InterruptedIOException;
+import java.util.ArrayList;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.RejectedExecutionException;
+import java.util.concurrent.TimeUnit;
+
+/* loaded from: classes4.dex */
+final class RealCall implements Call {
+    final OkHttpClient client;
+    private EventListener eventListener;
+    private boolean executed;
+    final boolean forWebSocket;
+    final Request originalRequest;
+    final RetryAndFollowUpInterceptor retryAndFollowUpInterceptor;
+    final AsyncTimeout timeout;
+
+    @Override // com.mbridge.msdk.thrid.okhttp.Call
+    public Request request() {
+        return this.originalRequest;
+    }
+
+    @Override // com.mbridge.msdk.thrid.okhttp.Call
+    public Timeout timeout() {
+        return this.timeout;
+    }
+
+    private RealCall(OkHttpClient okHttpClient, Request request, boolean z) {
+        this.client = okHttpClient;
+        this.originalRequest = request;
+        this.forWebSocket = z;
+        this.retryAndFollowUpInterceptor = new RetryAndFollowUpInterceptor(okHttpClient, z);
+        AsyncTimeout asyncTimeout = new AsyncTimeout() { // from class: com.mbridge.msdk.thrid.okhttp.RealCall.1
+            @Override // com.mbridge.msdk.thrid.okio.AsyncTimeout
+            public void timedOut() {
+                RealCall.this.cancel();
+            }
+        };
+        this.timeout = asyncTimeout;
+        asyncTimeout.timeout(okHttpClient.callTimeoutMillis(), TimeUnit.MILLISECONDS);
+    }
+
+    public static RealCall newRealCall(OkHttpClient okHttpClient, Request request, boolean z) {
+        RealCall realCall = new RealCall(okHttpClient, request, z);
+        realCall.eventListener = okHttpClient.eventListenerFactory().create(realCall);
+        return realCall;
+    }
+
+    @Override // com.mbridge.msdk.thrid.okhttp.Call
+    public Response execute() throws IOException {
+        synchronized (this) {
+            if (this.executed) {
+                throw new IllegalStateException("Already Executed");
+            }
+            this.executed = true;
+        }
+        captureCallStackTrace();
+        this.timeout.enter();
+        this.eventListener.callStart(this);
+        try {
+            try {
+                this.client.dispatcher().executed(this);
+                Response responseWithInterceptorChain = getResponseWithInterceptorChain();
+                if (responseWithInterceptorChain != null) {
+                    return responseWithInterceptorChain;
+                }
+                throw new IOException("Canceled");
+            } catch (IOException e) {
+                IOException timeoutExit = timeoutExit(e);
+                this.eventListener.callFailed(this, timeoutExit);
+                throw timeoutExit;
+            }
+        } finally {
+            this.client.dispatcher().finished(this);
+        }
+    }
+
+    public IOException timeoutExit(IOException iOException) {
+        if (!this.timeout.exit()) {
+            return iOException;
+        }
+        InterruptedIOException interruptedIOException = new InterruptedIOException("timeout");
+        if (iOException != null) {
+            interruptedIOException.initCause(iOException);
+        }
+        return interruptedIOException;
+    }
+
+    private void captureCallStackTrace() {
+        this.retryAndFollowUpInterceptor.setCallStackTrace(Platform.get().getStackTraceForCloseable("response.body().close()"));
+    }
+
+    @Override // com.mbridge.msdk.thrid.okhttp.Call
+    public void enqueue(Callback callback) {
+        synchronized (this) {
+            if (this.executed) {
+                throw new IllegalStateException("Already Executed");
+            }
+            this.executed = true;
+        }
+        captureCallStackTrace();
+        this.eventListener.callStart(this);
+        this.client.dispatcher().enqueue(new AsyncCall(callback));
+    }
+
+    @Override // com.mbridge.msdk.thrid.okhttp.Call
+    public void cancel() {
+        this.retryAndFollowUpInterceptor.cancel();
+    }
+
+    @Override // com.mbridge.msdk.thrid.okhttp.Call
+    public synchronized boolean isExecuted() {
+        return this.executed;
+    }
+
+    @Override // com.mbridge.msdk.thrid.okhttp.Call
+    public boolean isCanceled() {
+        return this.retryAndFollowUpInterceptor.isCanceled();
+    }
+
+    @Override // com.mbridge.msdk.thrid.okhttp.Call
+    /* renamed from: clone, reason: merged with bridge method [inline-methods] */
+    public RealCall m3721clone() {
+        return newRealCall(this.client, this.originalRequest, this.forWebSocket);
+    }
+
+    public StreamAllocation streamAllocation() {
+        return this.retryAndFollowUpInterceptor.streamAllocation();
+    }
+
+    public final class AsyncCall extends NamedRunnable {
+        static final /* synthetic */ boolean $assertionsDisabled = false;
+        private final Callback responseCallback;
+
+        public RealCall get() {
+            return RealCall.this;
+        }
+
+        public AsyncCall(Callback callback) {
+            super("OkHttp %s", RealCall.this.redactedUrl());
+            this.responseCallback = callback;
+        }
+
+        public String host() {
+            return RealCall.this.originalRequest.url().host();
+        }
+
+        public Request request() {
+            return RealCall.this.originalRequest;
+        }
+
+        public void executeOn(ExecutorService executorService) {
+            try {
+                try {
+                    executorService.execute(this);
+                } catch (RejectedExecutionException e) {
+                    InterruptedIOException interruptedIOException = new InterruptedIOException("executor rejected");
+                    interruptedIOException.initCause(e);
+                    RealCall.this.eventListener.callFailed(RealCall.this, interruptedIOException);
+                    this.responseCallback.onFailure(RealCall.this, interruptedIOException);
+                    RealCall.this.client.dispatcher().finished(this);
+                }
+            } catch (Throwable th) {
+                RealCall.this.client.dispatcher().finished(this);
+                throw th;
+            }
+        }
+
+        @Override // com.mbridge.msdk.thrid.okhttp.internal.NamedRunnable
+        public void execute() {
+            boolean z;
+            Throwable th;
+            IOException e;
+            RealCall.this.timeout.enter();
+            try {
+                try {
+                    z = true;
+                    try {
+                        this.responseCallback.onResponse(RealCall.this, RealCall.this.getResponseWithInterceptorChain());
+                    } catch (IOException e2) {
+                        e = e2;
+                        IOException timeoutExit = RealCall.this.timeoutExit(e);
+                        if (!z) {
+                            RealCall.this.eventListener.callFailed(RealCall.this, timeoutExit);
+                            this.responseCallback.onFailure(RealCall.this, timeoutExit);
+                        } else {
+                            Platform.get().log(4, "Callback failure for " + RealCall.this.toLoggableString(), timeoutExit);
+                        }
+                        RealCall.this.client.dispatcher().finished(this);
+                    } catch (Throwable th2) {
+                        th = th2;
+                        RealCall.this.cancel();
+                        if (!z) {
+                            this.responseCallback.onFailure(RealCall.this, new IOException("canceled due to " + th));
+                        }
+                        throw th;
+                    }
+                } catch (Throwable th3) {
+                    RealCall.this.client.dispatcher().finished(this);
+                    throw th3;
+                }
+            } catch (IOException e3) {
+                z = false;
+                e = e3;
+            } catch (Throwable th4) {
+                z = false;
+                th = th4;
+            }
+            RealCall.this.client.dispatcher().finished(this);
+        }
+    }
+
+    public String toLoggableString() {
+        StringBuilder sb = new StringBuilder();
+        sb.append(isCanceled() ? "canceled " : "");
+        sb.append(this.forWebSocket ? "web socket" : NotificationCompat.CATEGORY_CALL);
+        sb.append(" to ");
+        sb.append(redactedUrl());
+        return sb.toString();
+    }
+
+    public String redactedUrl() {
+        return this.originalRequest.url().redact();
+    }
+
+    public Response getResponseWithInterceptorChain() throws IOException {
+        ArrayList arrayList = new ArrayList();
+        arrayList.addAll(this.client.interceptors());
+        arrayList.add(this.retryAndFollowUpInterceptor);
+        arrayList.add(new BridgeInterceptor(this.client.cookieJar()));
+        arrayList.add(new CacheInterceptor(this.client.internalCache()));
+        arrayList.add(new ConnectInterceptor(this.client));
+        if (!this.forWebSocket) {
+            arrayList.addAll(this.client.networkInterceptors());
+        }
+        arrayList.add(new CallServerInterceptor(this.forWebSocket));
+        Response proceed = new RealInterceptorChain(arrayList, null, null, null, 0, this.originalRequest, this, this.eventListener, this.client.connectTimeoutMillis(), this.client.readTimeoutMillis(), this.client.writeTimeoutMillis()).proceed(this.originalRequest);
+        if (!this.retryAndFollowUpInterceptor.isCanceled()) {
+            return proceed;
+        }
+        Util.closeQuietly(proceed);
+        throw new IOException("Canceled");
+    }
+}

decompiled/sources/com/mbridge/msdk/thrid/okhttp/Request.java

@@ -0,0 +1,232 @@
+package com.mbridge.msdk.thrid.okhttp;
+
+import com.mbridge.msdk.thrid.okhttp.Headers;
+import com.mbridge.msdk.thrid.okhttp.internal.Util;
+import com.mbridge.msdk.thrid.okhttp.internal.http.HttpMethod;
+import java.net.URL;
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import org.apache.http.client.methods.HttpDelete;
+import org.apache.http.client.methods.HttpHead;
+import org.apache.http.client.methods.HttpPut;
+
+/* loaded from: classes4.dex */
+public final class Request {
+    final RequestBody body;
+    private volatile CacheControl cacheControl;
+    final Headers headers;
+    final String method;
+    final Map<Class<?>, Object> tags;
+    final HttpUrl url;
+
+    public RequestBody body() {
+        return this.body;
+    }
+
+    public Headers headers() {
+        return this.headers;
+    }
+
+    public String method() {
+        return this.method;
+    }
+
+    public HttpUrl url() {
+        return this.url;
+    }
+
+    public Request(Builder builder) {
+        this.url = builder.url;
+        this.method = builder.method;
+        this.headers = builder.headers.build();
+        this.body = builder.body;
+        this.tags = Util.immutableMap(builder.tags);
+    }
+
+    public String header(String str) {
+        return this.headers.get(str);
+    }
+
+    public List<String> headers(String str) {
+        return this.headers.values(str);
+    }
+
+    public Object tag() {
+        return tag(Object.class);
+    }
+
+    public <T> T tag(Class<? extends T> cls) {
+        return cls.cast(this.tags.get(cls));
+    }
+
+    public Builder newBuilder() {
+        return new Builder(this);
+    }
+
+    public CacheControl cacheControl() {
+        CacheControl cacheControl = this.cacheControl;
+        if (cacheControl != null) {
+            return cacheControl;
+        }
+        CacheControl parse = CacheControl.parse(this.headers);
+        this.cacheControl = parse;
+        return parse;
+    }
+
+    public boolean isHttps() {
+        return this.url.isHttps();
+    }
+
+    public String toString() {
+        return "Request{method=" + this.method + ", url=" + this.url + ", tags=" + this.tags + '}';
+    }
+
+    public static class Builder {
+        RequestBody body;
+        Headers.Builder headers;
+        String method;
+        Map<Class<?>, Object> tags;
+        HttpUrl url;
+
+        public Builder() {
+            this.tags = Collections.emptyMap();
+            this.method = "GET";
+            this.headers = new Headers.Builder();
+        }
+
+        public Builder(Request request) {
+            this.tags = Collections.emptyMap();
+            this.url = request.url;
+            this.method = request.method;
+            this.body = request.body;
+            this.tags = request.tags.isEmpty() ? Collections.emptyMap() : new LinkedHashMap<>(request.tags);
+            this.headers = request.headers.newBuilder();
+        }
+
+        public Builder url(HttpUrl httpUrl) {
+            if (httpUrl == null) {
+                throw new NullPointerException("url == null");
+            }
+            this.url = httpUrl;
+            return this;
+        }
+
+        public Builder url(String str) {
+            if (str == null) {
+                throw new NullPointerException("url == null");
+            }
+            if (str.regionMatches(true, 0, "ws:", 0, 3)) {
+                str = "http:" + str.substring(3);
+            } else if (str.regionMatches(true, 0, "wss:", 0, 4)) {
+                str = "https:" + str.substring(4);
+            }
+            return url(HttpUrl.get(str));
+        }
+
+        public Builder url(URL url) {
+            if (url == null) {
+                throw new NullPointerException("url == null");
+            }
+            return url(HttpUrl.get(url.toString()));
+        }
+
+        public Builder header(String str, String str2) {
+            this.headers.set(str, str2);
+            return this;
+        }
+
+        public Builder addHeader(String str, String str2) {
+            this.headers.add(str, str2);
+            return this;
+        }
+
+        public Builder removeHeader(String str) {
+            this.headers.removeAll(str);
+            return this;
+        }
+
+        public Builder headers(Headers headers) {
+            this.headers = headers.newBuilder();
+            return this;
+        }
+
+        public Builder cacheControl(CacheControl cacheControl) {
+            String cacheControl2 = cacheControl.toString();
+            return cacheControl2.isEmpty() ? removeHeader("Cache-Control") : header("Cache-Control", cacheControl2);
+        }
+
+        public Builder get() {
+            return method("GET", null);
+        }
+
+        public Builder head() {
+            return method(HttpHead.METHOD_NAME, null);
+        }
+
+        public Builder post(RequestBody requestBody) {
+            return method("POST", requestBody);
+        }
+
+        public Builder delete(RequestBody requestBody) {
+            return method(HttpDelete.METHOD_NAME, requestBody);
+        }
+
+        public Builder delete() {
+            return delete(Util.EMPTY_REQUEST);
+        }
+
+        public Builder put(RequestBody requestBody) {
+            return method(HttpPut.METHOD_NAME, requestBody);
+        }
+
+        public Builder patch(RequestBody requestBody) {
+            return method("PATCH", requestBody);
+        }
+
+        public Builder method(String str, RequestBody requestBody) {
+            if (str == null) {
+                throw new NullPointerException("method == null");
+            }
+            if (str.length() == 0) {
+                throw new IllegalArgumentException("method.length() == 0");
+            }
+            if (requestBody != null && !HttpMethod.permitsRequestBody(str)) {
+                throw new IllegalArgumentException("method " + str + " must not have a request body.");
+            }
+            if (requestBody != null || !HttpMethod.requiresRequestBody(str)) {
+                this.method = str;
+                this.body = requestBody;
+                return this;
+            }
+            throw new IllegalArgumentException("method " + str + " must have a request body.");
+        }
+
+        public Builder tag(Object obj) {
+            return tag(Object.class, obj);
+        }
+
+        public <T> Builder tag(Class<? super T> cls, T t) {
+            if (cls == null) {
+                throw new NullPointerException("type == null");
+            }
+            if (t == null) {
+                this.tags.remove(cls);
+            } else {
+                if (this.tags.isEmpty()) {
+                    this.tags = new LinkedHashMap();
+                }
+                this.tags.put(cls, cls.cast(t));
+            }
+            return this;
+        }
+
+        public Request build() {
+            if (this.url == null) {
+                throw new IllegalStateException("url == null");
+            }
+            return new Request(this);
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/thrid/okhttp/RequestBody.java

@@ -0,0 +1,108 @@
+package com.mbridge.msdk.thrid.okhttp;
+
+import com.mbridge.msdk.thrid.okhttp.internal.Util;
+import com.mbridge.msdk.thrid.okio.BufferedSink;
+import com.mbridge.msdk.thrid.okio.ByteString;
+import com.mbridge.msdk.thrid.okio.Okio;
+import com.mbridge.msdk.thrid.okio.Source;
+import java.io.File;
+import java.io.IOException;
+import java.nio.charset.Charset;
+
+/* loaded from: classes4.dex */
+public abstract class RequestBody {
+    public long contentLength() throws IOException {
+        return -1L;
+    }
+
+    public abstract MediaType contentType();
+
+    public abstract void writeTo(BufferedSink bufferedSink) throws IOException;
+
+    public static RequestBody create(MediaType mediaType, String str) {
+        Charset charset = Util.UTF_8;
+        if (mediaType != null) {
+            Charset charset2 = mediaType.charset();
+            if (charset2 == null) {
+                mediaType = MediaType.parse(mediaType + "; charset=utf-8");
+            } else {
+                charset = charset2;
+            }
+        }
+        return create(mediaType, str.getBytes(charset));
+    }
+
+    public static RequestBody create(final MediaType mediaType, final ByteString byteString) {
+        return new RequestBody() { // from class: com.mbridge.msdk.thrid.okhttp.RequestBody.1
+            @Override // com.mbridge.msdk.thrid.okhttp.RequestBody
+            public MediaType contentType() {
+                return MediaType.this;
+            }
+
+            @Override // com.mbridge.msdk.thrid.okhttp.RequestBody
+            public long contentLength() throws IOException {
+                return byteString.size();
+            }
+
+            @Override // com.mbridge.msdk.thrid.okhttp.RequestBody
+            public void writeTo(BufferedSink bufferedSink) throws IOException {
+                bufferedSink.write(byteString);
+            }
+        };
+    }
+
+    public static RequestBody create(MediaType mediaType, byte[] bArr) {
+        return create(mediaType, bArr, 0, bArr.length);
+    }
+
+    public static RequestBody create(final MediaType mediaType, final byte[] bArr, final int i, final int i2) {
+        if (bArr == null) {
+            throw new NullPointerException("content == null");
+        }
+        Util.checkOffsetAndCount(bArr.length, i, i2);
+        return new RequestBody() { // from class: com.mbridge.msdk.thrid.okhttp.RequestBody.2
+            @Override // com.mbridge.msdk.thrid.okhttp.RequestBody
+            public long contentLength() {
+                return i2;
+            }
+
+            @Override // com.mbridge.msdk.thrid.okhttp.RequestBody
+            public MediaType contentType() {
+                return MediaType.this;
+            }
+
+            @Override // com.mbridge.msdk.thrid.okhttp.RequestBody
+            public void writeTo(BufferedSink bufferedSink) throws IOException {
+                bufferedSink.write(bArr, i, i2);
+            }
+        };
+    }
+
+    public static RequestBody create(final MediaType mediaType, final File file) {
+        if (file == null) {
+            throw new NullPointerException("file == null");
+        }
+        return new RequestBody() { // from class: com.mbridge.msdk.thrid.okhttp.RequestBody.3
+            @Override // com.mbridge.msdk.thrid.okhttp.RequestBody
+            public MediaType contentType() {
+                return MediaType.this;
+            }
+
+            @Override // com.mbridge.msdk.thrid.okhttp.RequestBody
+            public long contentLength() {
+                return file.length();
+            }
+
+            @Override // com.mbridge.msdk.thrid.okhttp.RequestBody
+            public void writeTo(BufferedSink bufferedSink) throws IOException {
+                Source source = null;
+                try {
+                    source = Okio.source(file);
+                    bufferedSink.writeAll(source);
+                } finally {
+                    Util.closeQuietly(source);
+                }
+            }
+        };
+    }
+}

decompiled/sources/com/mbridge/msdk/thrid/okhttp/Response.java

@@ -0,0 +1,338 @@
+package com.mbridge.msdk.thrid.okhttp;
+
+import com.mbridge.msdk.thrid.okhttp.Headers;
+import com.mbridge.msdk.thrid.okhttp.internal.http.HttpHeaders;
+import com.mbridge.msdk.thrid.okio.Buffer;
+import com.mbridge.msdk.thrid.okio.BufferedSource;
+import java.io.Closeable;
+import java.io.IOException;
+import java.util.Collections;
+import java.util.List;
+import org.apache.http.HttpStatus;
+import org.apache.http.auth.AUTH;
+
+/* loaded from: classes4.dex */
+public final class Response implements Closeable {
+    final ResponseBody body;
+    private volatile CacheControl cacheControl;
+    final Response cacheResponse;
+    final int code;
+    final Handshake handshake;
+    final Headers headers;
+    final String message;
+    final Response networkResponse;
+    final Response priorResponse;
+    final Protocol protocol;
+    final long receivedResponseAtMillis;
+    final Request request;
+    final long sentRequestAtMillis;
+
+    public ResponseBody body() {
+        return this.body;
+    }
+
+    public Response cacheResponse() {
+        return this.cacheResponse;
+    }
+
+    public int code() {
+        return this.code;
+    }
+
+    public Handshake handshake() {
+        return this.handshake;
+    }
+
+    public Headers headers() {
+        return this.headers;
+    }
+
+    public boolean isRedirect() {
+        int i = this.code;
+        if (i == 307 || i == 308) {
+            return true;
+        }
+        switch (i) {
+            case 300:
+            case 301:
+            case 302:
+            case HttpStatus.SC_SEE_OTHER /* 303 */:
+                return true;
+            default:
+                return false;
+        }
+    }
+
+    public boolean isSuccessful() {
+        int i = this.code;
+        return i >= 200 && i < 300;
+    }
+
+    public String message() {
+        return this.message;
+    }
+
+    public Response networkResponse() {
+        return this.networkResponse;
+    }
+
+    public Response priorResponse() {
+        return this.priorResponse;
+    }
+
+    public Protocol protocol() {
+        return this.protocol;
+    }
+
+    public long receivedResponseAtMillis() {
+        return this.receivedResponseAtMillis;
+    }
+
+    public Request request() {
+        return this.request;
+    }
+
+    public long sentRequestAtMillis() {
+        return this.sentRequestAtMillis;
+    }
+
+    public Response(Builder builder) {
+        this.request = builder.request;
+        this.protocol = builder.protocol;
+        this.code = builder.code;
+        this.message = builder.message;
+        this.handshake = builder.handshake;
+        this.headers = builder.headers.build();
+        this.body = builder.body;
+        this.networkResponse = builder.networkResponse;
+        this.cacheResponse = builder.cacheResponse;
+        this.priorResponse = builder.priorResponse;
+        this.sentRequestAtMillis = builder.sentRequestAtMillis;
+        this.receivedResponseAtMillis = builder.receivedResponseAtMillis;
+    }
+
+    public List<String> headers(String str) {
+        return this.headers.values(str);
+    }
+
+    public String header(String str) {
+        return header(str, null);
+    }
+
+    public String header(String str, String str2) {
+        String str3 = this.headers.get(str);
+        return str3 != null ? str3 : str2;
+    }
+
+    public ResponseBody peekBody(long j) throws IOException {
+        BufferedSource source = this.body.source();
+        source.request(j);
+        Buffer m3722clone = source.buffer().m3722clone();
+        if (m3722clone.size() > j) {
+            Buffer buffer = new Buffer();
+            buffer.write(m3722clone, j);
+            m3722clone.clear();
+            m3722clone = buffer;
+        }
+        return ResponseBody.create(this.body.contentType(), m3722clone.size(), m3722clone);
+    }
+
+    public Builder newBuilder() {
+        return new Builder(this);
+    }
+
+    public List<Challenge> challenges() {
+        String str;
+        int i = this.code;
+        if (i == 401) {
+            str = AUTH.WWW_AUTH;
+        } else {
+            if (i != 407) {
+                return Collections.emptyList();
+            }
+            str = AUTH.PROXY_AUTH;
+        }
+        return HttpHeaders.parseChallenges(headers(), str);
+    }
+
+    public CacheControl cacheControl() {
+        CacheControl cacheControl = this.cacheControl;
+        if (cacheControl != null) {
+            return cacheControl;
+        }
+        CacheControl parse = CacheControl.parse(this.headers);
+        this.cacheControl = parse;
+        return parse;
+    }
+
+    @Override // java.io.Closeable, java.lang.AutoCloseable
+    public void close() {
+        ResponseBody responseBody = this.body;
+        if (responseBody == null) {
+            throw new IllegalStateException("response is not eligible for a body and must not be closed");
+        }
+        responseBody.close();
+    }
+
+    public String toString() {
+        return "Response{protocol=" + this.protocol + ", code=" + this.code + ", message=" + this.message + ", url=" + this.request.url() + '}';
+    }
+
+    public static class Builder {
+        ResponseBody body;
+        Response cacheResponse;
+        int code;
+        Handshake handshake;
+        Headers.Builder headers;
+        String message;
+        Response networkResponse;
+        Response priorResponse;
+        Protocol protocol;
+        long receivedResponseAtMillis;
+        Request request;
+        long sentRequestAtMillis;
+
+        public Builder body(ResponseBody responseBody) {
+            this.body = responseBody;
+            return this;
+        }
+
+        public Builder code(int i) {
+            this.code = i;
+            return this;
+        }
+
+        public Builder handshake(Handshake handshake) {
+            this.handshake = handshake;
+            return this;
+        }
+
+        public Builder message(String str) {
+            this.message = str;
+            return this;
+        }
+
+        public Builder protocol(Protocol protocol) {
+            this.protocol = protocol;
+            return this;
+        }
+
+        public Builder receivedResponseAtMillis(long j) {
+            this.receivedResponseAtMillis = j;
+            return this;
+        }
+
+        public Builder request(Request request) {
+            this.request = request;
+            return this;
+        }
+
+        public Builder sentRequestAtMillis(long j) {
+            this.sentRequestAtMillis = j;
+            return this;
+        }
+
+        public Builder() {
+            this.code = -1;
+            this.headers = new Headers.Builder();
+        }
+
+        public Builder(Response response) {
+            this.code = -1;
+            this.request = response.request;
+            this.protocol = response.protocol;
+            this.code = response.code;
+            this.message = response.message;
+            this.handshake = response.handshake;
+            this.headers = response.headers.newBuilder();
+            this.body = response.body;
+            this.networkResponse = response.networkResponse;
+            this.cacheResponse = response.cacheResponse;
+            this.priorResponse = response.priorResponse;
+            this.sentRequestAtMillis = response.sentRequestAtMillis;
+            this.receivedResponseAtMillis = response.receivedResponseAtMillis;
+        }
+
+        public Builder header(String str, String str2) {
+            this.headers.set(str, str2);
+            return this;
+        }
+
+        public Builder addHeader(String str, String str2) {
+            this.headers.add(str, str2);
+            return this;
+        }
+
+        public Builder removeHeader(String str) {
+            this.headers.removeAll(str);
+            return this;
+        }
+
+        public Builder headers(Headers headers) {
+            this.headers = headers.newBuilder();
+            return this;
+        }
+
+        public Builder networkResponse(Response response) {
+            if (response != null) {
+                checkSupportResponse("networkResponse", response);
+            }
+            this.networkResponse = response;
+            return this;
+        }
+
+        public Builder cacheResponse(Response response) {
+            if (response != null) {
+                checkSupportResponse("cacheResponse", response);
+            }
+            this.cacheResponse = response;
+            return this;
+        }
+
+        private void checkSupportResponse(String str, Response response) {
+            if (response.body != null) {
+                throw new IllegalArgumentException(str + ".body != null");
+            }
+            if (response.networkResponse != null) {
+                throw new IllegalArgumentException(str + ".networkResponse != null");
+            }
+            if (response.cacheResponse != null) {
+                throw new IllegalArgumentException(str + ".cacheResponse != null");
+            }
+            if (response.priorResponse == null) {
+                return;
+            }
+            throw new IllegalArgumentException(str + ".priorResponse != null");
+        }
+
+        public Builder priorResponse(Response response) {
+            if (response != null) {
+                checkPriorResponse(response);
+            }
+            this.priorResponse = response;
+            return this;
+        }
+
+        private void checkPriorResponse(Response response) {
+            if (response.body != null) {
+                throw new IllegalArgumentException("priorResponse.body != null");
+            }
+        }
+
+        public Response build() {
+            if (this.request == null) {
+                throw new IllegalStateException("request == null");
+            }
+            if (this.protocol == null) {
+                throw new IllegalStateException("protocol == null");
+            }
+            if (this.code >= 0) {
+                if (this.message == null) {
+                    throw new IllegalStateException("message == null");
+                }
+                return new Response(this);
+            }
+            throw new IllegalStateException("code < 0: " + this.code);
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/thrid/okhttp/ResponseBody.java

@@ -0,0 +1,156 @@
+package com.mbridge.msdk.thrid.okhttp;
+
+import com.mbridge.msdk.thrid.okhttp.internal.Util;
+import com.mbridge.msdk.thrid.okio.Buffer;
+import com.mbridge.msdk.thrid.okio.BufferedSource;
+import com.mbridge.msdk.thrid.okio.ByteString;
+import java.io.Closeable;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.Reader;
+import java.nio.charset.Charset;
+
+/* loaded from: classes4.dex */
+public abstract class ResponseBody implements Closeable {
+    private Reader reader;
+
+    public abstract long contentLength();
+
+    public abstract MediaType contentType();
+
+    public abstract BufferedSource source();
+
+    public final InputStream byteStream() {
+        return source().inputStream();
+    }
+
+    public final byte[] bytes() throws IOException {
+        long contentLength = contentLength();
+        if (contentLength > 2147483647L) {
+            throw new IOException("Cannot buffer entire body for content length: " + contentLength);
+        }
+        BufferedSource source = source();
+        try {
+            byte[] readByteArray = source.readByteArray();
+            Util.closeQuietly(source);
+            if (contentLength == -1 || contentLength == readByteArray.length) {
+                return readByteArray;
+            }
+            throw new IOException("Content-Length (" + contentLength + ") and stream length (" + readByteArray.length + ") disagree");
+        } catch (Throwable th) {
+            Util.closeQuietly(source);
+            throw th;
+        }
+    }
+
+    public final Reader charStream() {
+        Reader reader = this.reader;
+        if (reader != null) {
+            return reader;
+        }
+        BomAwareReader bomAwareReader = new BomAwareReader(source(), charset());
+        this.reader = bomAwareReader;
+        return bomAwareReader;
+    }
+
+    public final String string() throws IOException {
+        BufferedSource source = source();
+        try {
+            return source.readString(Util.bomAwareCharset(source, charset()));
+        } finally {
+            Util.closeQuietly(source);
+        }
+    }
+
+    private Charset charset() {
+        MediaType contentType = contentType();
+        return contentType != null ? contentType.charset(Util.UTF_8) : Util.UTF_8;
+    }
+
+    @Override // java.io.Closeable, java.lang.AutoCloseable
+    public void close() {
+        Util.closeQuietly(source());
+    }
+
+    public static ResponseBody create(MediaType mediaType, String str) {
+        Charset charset = Util.UTF_8;
+        if (mediaType != null) {
+            Charset charset2 = mediaType.charset();
+            if (charset2 == null) {
+                mediaType = MediaType.parse(mediaType + "; charset=utf-8");
+            } else {
+                charset = charset2;
+            }
+        }
+        Buffer writeString = new Buffer().writeString(str, charset);
+        return create(mediaType, writeString.size(), writeString);
+    }
+
+    public static ResponseBody create(MediaType mediaType, byte[] bArr) {
+        return create(mediaType, bArr.length, new Buffer().write(bArr));
+    }
+
+    public static ResponseBody create(MediaType mediaType, ByteString byteString) {
+        return create(mediaType, byteString.size(), new Buffer().write(byteString));
+    }
+
+    public static ResponseBody create(final MediaType mediaType, final long j, final BufferedSource bufferedSource) {
+        if (bufferedSource == null) {
+            throw new NullPointerException("source == null");
+        }
+        return new ResponseBody() { // from class: com.mbridge.msdk.thrid.okhttp.ResponseBody.1
+            @Override // com.mbridge.msdk.thrid.okhttp.ResponseBody
+            public long contentLength() {
+                return j;
+            }
+
+            @Override // com.mbridge.msdk.thrid.okhttp.ResponseBody
+            public MediaType contentType() {
+                return MediaType.this;
+            }
+
+            @Override // com.mbridge.msdk.thrid.okhttp.ResponseBody
+            public BufferedSource source() {
+                return bufferedSource;
+            }
+        };
+    }
+
+    public static final class BomAwareReader extends Reader {
+        private final Charset charset;
+        private boolean closed;
+        private Reader delegate;
+        private final BufferedSource source;
+
+        public BomAwareReader(BufferedSource bufferedSource, Charset charset) {
+            this.source = bufferedSource;
+            this.charset = charset;
+        }
+
+        @Override // java.io.Reader
+        public int read(char[] cArr, int i, int i2) throws IOException {
+            if (this.closed) {
+                throw new IOException("Stream closed");
+            }
+            Reader reader = this.delegate;
+            if (reader == null) {
+                InputStreamReader inputStreamReader = new InputStreamReader(this.source.inputStream(), Util.bomAwareCharset(this.source, this.charset));
+                this.delegate = inputStreamReader;
+                reader = inputStreamReader;
+            }
+            return reader.read(cArr, i, i2);
+        }
+
+        @Override // java.io.Reader, java.io.Closeable, java.lang.AutoCloseable
+        public void close() throws IOException {
+            this.closed = true;
+            Reader reader = this.delegate;
+            if (reader != null) {
+                reader.close();
+            } else {
+                this.source.close();
+            }
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/thrid/okhttp/Route.java

@@ -0,0 +1,61 @@
+package com.mbridge.msdk.thrid.okhttp;
+
+import com.ironsource.mediationsdk.logger.IronSourceError;
+import java.net.InetSocketAddress;
+import java.net.Proxy;
+
+/* loaded from: classes4.dex */
+public final class Route {
+    final Address address;
+    final InetSocketAddress inetSocketAddress;
+    final Proxy proxy;
+
+    public Address address() {
+        return this.address;
+    }
+
+    public Proxy proxy() {
+        return this.proxy;
+    }
+
+    public InetSocketAddress socketAddress() {
+        return this.inetSocketAddress;
+    }
+
+    public Route(Address address, Proxy proxy, InetSocketAddress inetSocketAddress) {
+        if (address == null) {
+            throw new NullPointerException("address == null");
+        }
+        if (proxy == null) {
+            throw new NullPointerException("proxy == null");
+        }
+        if (inetSocketAddress == null) {
+            throw new NullPointerException("inetSocketAddress == null");
+        }
+        this.address = address;
+        this.proxy = proxy;
+        this.inetSocketAddress = inetSocketAddress;
+    }
+
+    public boolean requiresTunnel() {
+        return this.address.sslSocketFactory != null && this.proxy.type() == Proxy.Type.HTTP;
+    }
+
+    public boolean equals(Object obj) {
+        if (obj instanceof Route) {
+            Route route = (Route) obj;
+            if (route.address.equals(this.address) && route.proxy.equals(this.proxy) && route.inetSocketAddress.equals(this.inetSocketAddress)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public int hashCode() {
+        return ((((IronSourceError.ERROR_NON_EXISTENT_INSTANCE + this.address.hashCode()) * 31) + this.proxy.hashCode()) * 31) + this.inetSocketAddress.hashCode();
+    }
+
+    public String toString() {
+        return "Route{" + this.inetSocketAddress + "}";
+    }
+}

decompiled/sources/com/mbridge/msdk/thrid/okhttp/TlsVersion.java

@@ -0,0 +1,50 @@
+package com.mbridge.msdk.thrid.okhttp;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+/* loaded from: classes4.dex */
+public enum TlsVersion {
+    TLS_1_3("TLSv1.3"),
+    TLS_1_2("TLSv1.2"),
+    TLS_1_1("TLSv1.1"),
+    TLS_1_0("TLSv1"),
+    SSL_3_0("SSLv3");
+
+    final String javaName;
+
+    public String javaName() {
+        return this.javaName;
+    }
+
+    TlsVersion(String str) {
+        this.javaName = str;
+    }
+
+    public static TlsVersion forJavaName(String str) {
+        str.hashCode();
+        switch (str) {
+            case "TLSv1.1":
+                return TLS_1_1;
+            case "TLSv1.2":
+                return TLS_1_2;
+            case "TLSv1.3":
+                return TLS_1_3;
+            case "SSLv3":
+                return SSL_3_0;
+            case "TLSv1":
+                return TLS_1_0;
+            default:
+                throw new IllegalArgumentException("Unexpected TLS version: " + str);
+        }
+    }
+
+    public static List<TlsVersion> forJavaNames(String... strArr) {
+        ArrayList arrayList = new ArrayList(strArr.length);
+        for (String str : strArr) {
+            arrayList.add(forJavaName(str));
+        }
+        return Collections.unmodifiableList(arrayList);
+    }
+}

decompiled/sources/com/mbridge/msdk/thrid/okhttp/WebSocket.java

@@ -0,0 +1,23 @@
+package com.mbridge.msdk.thrid.okhttp;
+
+import com.mbridge.msdk.thrid.okio.ByteString;
+
+/* loaded from: classes4.dex */
+public interface WebSocket {
+
+    public interface Factory {
+        WebSocket newWebSocket(Request request, WebSocketListener webSocketListener);
+    }
+
+    void cancel();
+
+    boolean close(int i, String str);
+
+    long queueSize();
+
+    Request request();
+
+    boolean send(ByteString byteString);
+
+    boolean send(String str);
+}

decompiled/sources/com/mbridge/msdk/thrid/okhttp/WebSocketListener.java

@@ -0,0 +1,24 @@
+package com.mbridge.msdk.thrid.okhttp;
+
+import com.mbridge.msdk.thrid.okio.ByteString;
+
+/* loaded from: classes4.dex */
+public abstract class WebSocketListener {
+    public void onClosed(WebSocket webSocket, int i, String str) {
+    }
+
+    public void onClosing(WebSocket webSocket, int i, String str) {
+    }
+
+    public void onFailure(WebSocket webSocket, Throwable th, Response response) {
+    }
+
+    public void onMessage(WebSocket webSocket, ByteString byteString) {
+    }
+
+    public void onMessage(WebSocket webSocket, String str) {
+    }
+
+    public void onOpen(WebSocket webSocket, Response response) {
+    }
+}

decompiled/sources/com/mbridge/msdk/thrid/okhttp/internal/Internal.java

@@ -0,0 +1,57 @@
+package com.mbridge.msdk.thrid.okhttp.internal;
+
+import com.mbridge.msdk.thrid.okhttp.Address;
+import com.mbridge.msdk.thrid.okhttp.Call;
+import com.mbridge.msdk.thrid.okhttp.ConnectionPool;
+import com.mbridge.msdk.thrid.okhttp.ConnectionSpec;
+import com.mbridge.msdk.thrid.okhttp.Headers;
+import com.mbridge.msdk.thrid.okhttp.OkHttpClient;
+import com.mbridge.msdk.thrid.okhttp.Request;
+import com.mbridge.msdk.thrid.okhttp.Response;
+import com.mbridge.msdk.thrid.okhttp.Route;
+import com.mbridge.msdk.thrid.okhttp.internal.cache.InternalCache;
+import com.mbridge.msdk.thrid.okhttp.internal.connection.RealConnection;
+import com.mbridge.msdk.thrid.okhttp.internal.connection.RouteDatabase;
+import com.mbridge.msdk.thrid.okhttp.internal.connection.StreamAllocation;
+import java.io.IOException;
+import java.net.Socket;
+import javax.net.ssl.SSLSocket;
+
+/* loaded from: classes4.dex */
+public abstract class Internal {
+    public static Internal instance;
+
+    public abstract void addLenient(Headers.Builder builder, String str);
+
+    public abstract void addLenient(Headers.Builder builder, String str, String str2);
+
+    public abstract void apply(ConnectionSpec connectionSpec, SSLSocket sSLSocket, boolean z);
+
+    public abstract int code(Response.Builder builder);
+
+    public abstract boolean connectionBecameIdle(ConnectionPool connectionPool, RealConnection realConnection);
+
+    public abstract Socket deduplicate(ConnectionPool connectionPool, Address address, StreamAllocation streamAllocation);
+
+    public abstract boolean equalsNonHost(Address address, Address address2);
+
+    public abstract RealConnection get(ConnectionPool connectionPool, Address address, StreamAllocation streamAllocation, Route route);
+
+    public abstract boolean isInvalidHttpUrlHost(IllegalArgumentException illegalArgumentException);
+
+    public abstract Call newWebSocketCall(OkHttpClient okHttpClient, Request request);
+
+    public abstract void put(ConnectionPool connectionPool, RealConnection realConnection);
+
+    public abstract RouteDatabase routeDatabase(ConnectionPool connectionPool);
+
+    public abstract void setCache(OkHttpClient.Builder builder, InternalCache internalCache);
+
+    public abstract StreamAllocation streamAllocation(Call call);
+
+    public abstract IOException timeoutExit(Call call, IOException iOException);
+
+    public static void initializeInstanceForTests() {
+        new OkHttpClient();
+    }
+}

decompiled/sources/com/mbridge/msdk/thrid/okhttp/internal/NamedRunnable.java

@@ -0,0 +1,23 @@
+package com.mbridge.msdk.thrid.okhttp.internal;
+
+/* loaded from: classes4.dex */
+public abstract class NamedRunnable implements Runnable {
+    protected final String name;
+
+    public abstract void execute();
+
+    public NamedRunnable(String str, Object... objArr) {
+        this.name = Util.format(str, objArr);
+    }
+
+    @Override // java.lang.Runnable
+    public final void run() {
+        String name = Thread.currentThread().getName();
+        Thread.currentThread().setName(this.name);
+        try {
+            execute();
+        } finally {
+            Thread.currentThread().setName(name);
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/thrid/okhttp/internal/Util.java

@@ -0,0 +1,661 @@
+package com.mbridge.msdk.thrid.okhttp.internal;
+
+import android.support.v4.media.session.PlaybackStateCompat;
+import com.facebook.internal.security.CertificateUtil;
+import com.ironsource.v8;
+import com.mbridge.msdk.thrid.okhttp.Headers;
+import com.mbridge.msdk.thrid.okhttp.HttpUrl;
+import com.mbridge.msdk.thrid.okhttp.MediaType;
+import com.mbridge.msdk.thrid.okhttp.RequestBody;
+import com.mbridge.msdk.thrid.okhttp.ResponseBody;
+import com.mbridge.msdk.thrid.okhttp.internal.http2.Header;
+import com.mbridge.msdk.thrid.okio.Buffer;
+import com.mbridge.msdk.thrid.okio.BufferedSource;
+import com.mbridge.msdk.thrid.okio.ByteString;
+import com.mbridge.msdk.thrid.okio.Source;
+import java.io.Closeable;
+import java.io.IOException;
+import java.io.InterruptedIOException;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.net.IDN;
+import java.net.InetAddress;
+import java.net.ServerSocket;
+import java.net.Socket;
+import java.nio.charset.Charset;
+import java.security.GeneralSecurityException;
+import java.security.KeyStore;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.TimeZone;
+import java.util.concurrent.ThreadFactory;
+import java.util.concurrent.TimeUnit;
+import java.util.regex.Pattern;
+import javax.net.ssl.TrustManager;
+import javax.net.ssl.TrustManagerFactory;
+import javax.net.ssl.X509TrustManager;
+
+/* loaded from: classes4.dex */
+public final class Util {
+    public static final byte[] EMPTY_BYTE_ARRAY;
+    public static final RequestBody EMPTY_REQUEST;
+    public static final ResponseBody EMPTY_RESPONSE;
+    private static final Pattern VERIFY_AS_IP_ADDRESS;
+    private static final Method addSuppressedExceptionMethod;
+    public static final String[] EMPTY_STRING_ARRAY = new String[0];
+    private static final ByteString UTF_8_BOM = ByteString.decodeHex("efbbbf");
+    private static final ByteString UTF_16_BE_BOM = ByteString.decodeHex("feff");
+    private static final ByteString UTF_16_LE_BOM = ByteString.decodeHex("fffe");
+    private static final ByteString UTF_32_BE_BOM = ByteString.decodeHex("0000ffff");
+    private static final ByteString UTF_32_LE_BOM = ByteString.decodeHex("ffff0000");
+    public static final Charset UTF_8 = Charset.forName("UTF-8");
+    public static final Charset ISO_8859_1 = Charset.forName("ISO-8859-1");
+    private static final Charset UTF_16_BE = Charset.forName("UTF-16BE");
+    private static final Charset UTF_16_LE = Charset.forName("UTF-16LE");
+    private static final Charset UTF_32_BE = Charset.forName("UTF-32BE");
+    private static final Charset UTF_32_LE = Charset.forName("UTF-32LE");
+    public static final TimeZone UTC = TimeZone.getTimeZone("GMT");
+    public static final Comparator<String> NATURAL_ORDER = new Comparator<String>() { // from class: com.mbridge.msdk.thrid.okhttp.internal.Util.1
+        @Override // java.util.Comparator
+        public int compare(String str, String str2) {
+            return str.compareTo(str2);
+        }
+    };
+
+    public static int decodeHexDigit(char c) {
+        if (c >= '0' && c <= '9') {
+            return c - '0';
+        }
+        if (c >= 'a' && c <= 'f') {
+            return c - 'W';
+        }
+        if (c < 'A' || c > 'F') {
+            return -1;
+        }
+        return c - '7';
+    }
+
+    static {
+        byte[] bArr = new byte[0];
+        EMPTY_BYTE_ARRAY = bArr;
+        Method method = null;
+        EMPTY_RESPONSE = ResponseBody.create((MediaType) null, bArr);
+        EMPTY_REQUEST = RequestBody.create((MediaType) null, bArr);
+        try {
+            method = Throwable.class.getDeclaredMethod("addSuppressed", Throwable.class);
+        } catch (Exception unused) {
+        }
+        addSuppressedExceptionMethod = method;
+        VERIFY_AS_IP_ADDRESS = Pattern.compile("([0-9a-fA-F]*:[0-9a-fA-F:.]*)|([\\d.]+)");
+    }
+
+    public static void addSuppressedIfPossible(Throwable th, Throwable th2) {
+        Method method = addSuppressedExceptionMethod;
+        if (method != null) {
+            try {
+                method.invoke(th, th2);
+            } catch (IllegalAccessException | InvocationTargetException unused) {
+            }
+        }
+    }
+
+    private Util() {
+    }
+
+    public static void checkOffsetAndCount(long j, long j2, long j3) {
+        if ((j2 | j3) < 0 || j2 > j || j - j2 < j3) {
+            throw new ArrayIndexOutOfBoundsException();
+        }
+    }
+
+    public static boolean equal(Object obj, Object obj2) {
+        return obj == obj2 || (obj != null && obj.equals(obj2));
+    }
+
+    public static void closeQuietly(Closeable closeable) {
+        if (closeable != null) {
+            try {
+                closeable.close();
+            } catch (RuntimeException e) {
+                throw e;
+            } catch (Exception unused) {
+            }
+        }
+    }
+
+    public static void closeQuietly(Socket socket) {
+        if (socket != null) {
+            try {
+                socket.close();
+            } catch (AssertionError e) {
+                if (!isAndroidGetsocknameError(e)) {
+                    throw e;
+                }
+            } catch (RuntimeException e2) {
+                if (!"bio == null".equals(e2.getMessage())) {
+                    throw e2;
+                }
+            } catch (Exception unused) {
+            }
+        }
+    }
+
+    public static void closeQuietly(ServerSocket serverSocket) {
+        if (serverSocket != null) {
+            try {
+                serverSocket.close();
+            } catch (RuntimeException e) {
+                throw e;
+            } catch (Exception unused) {
+            }
+        }
+    }
+
+    public static boolean discard(Source source, int i, TimeUnit timeUnit) {
+        try {
+            return skipAll(source, i, timeUnit);
+        } catch (IOException unused) {
+            return false;
+        }
+    }
+
+    public static boolean skipAll(Source source, int i, TimeUnit timeUnit) throws IOException {
+        long nanoTime = System.nanoTime();
+        long deadlineNanoTime = source.timeout().hasDeadline() ? source.timeout().deadlineNanoTime() - nanoTime : Long.MAX_VALUE;
+        source.timeout().deadlineNanoTime(Math.min(deadlineNanoTime, timeUnit.toNanos(i)) + nanoTime);
+        try {
+            Buffer buffer = new Buffer();
+            while (source.read(buffer, PlaybackStateCompat.ACTION_PLAY_FROM_URI) != -1) {
+                buffer.clear();
+            }
+            if (deadlineNanoTime == Long.MAX_VALUE) {
+                source.timeout().clearDeadline();
+                return true;
+            }
+            source.timeout().deadlineNanoTime(nanoTime + deadlineNanoTime);
+            return true;
+        } catch (InterruptedIOException unused) {
+            if (deadlineNanoTime == Long.MAX_VALUE) {
+                source.timeout().clearDeadline();
+                return false;
+            }
+            source.timeout().deadlineNanoTime(nanoTime + deadlineNanoTime);
+            return false;
+        } catch (Throwable th) {
+            if (deadlineNanoTime == Long.MAX_VALUE) {
+                source.timeout().clearDeadline();
+            } else {
+                source.timeout().deadlineNanoTime(nanoTime + deadlineNanoTime);
+            }
+            throw th;
+        }
+    }
+
+    public static <T> List<T> immutableList(List<T> list) {
+        return Collections.unmodifiableList(new ArrayList(list));
+    }
+
+    public static <K, V> Map<K, V> immutableMap(Map<K, V> map) {
+        if (map.isEmpty()) {
+            return Collections.emptyMap();
+        }
+        return Collections.unmodifiableMap(new LinkedHashMap(map));
+    }
+
+    public static <T> List<T> immutableList(T... tArr) {
+        return Collections.unmodifiableList(Arrays.asList((Object[]) tArr.clone()));
+    }
+
+    public static ThreadFactory threadFactory(final String str, final boolean z) {
+        return new ThreadFactory() { // from class: com.mbridge.msdk.thrid.okhttp.internal.Util.2
+            @Override // java.util.concurrent.ThreadFactory
+            public Thread newThread(Runnable runnable) {
+                Thread thread = new Thread(runnable, str);
+                thread.setDaemon(z);
+                return thread;
+            }
+        };
+    }
+
+    public static String[] intersect(Comparator<? super String> comparator, String[] strArr, String[] strArr2) {
+        ArrayList arrayList = new ArrayList();
+        for (String str : strArr) {
+            int length = strArr2.length;
+            int i = 0;
+            while (true) {
+                if (i >= length) {
+                    break;
+                }
+                if (comparator.compare(str, strArr2[i]) == 0) {
+                    arrayList.add(str);
+                    break;
+                }
+                i++;
+            }
+        }
+        return (String[]) arrayList.toArray(new String[arrayList.size()]);
+    }
+
+    public static boolean nonEmptyIntersection(Comparator<String> comparator, String[] strArr, String[] strArr2) {
+        if (strArr != null && strArr2 != null && strArr.length != 0 && strArr2.length != 0) {
+            for (String str : strArr) {
+                for (String str2 : strArr2) {
+                    if (comparator.compare(str, str2) == 0) {
+                        return true;
+                    }
+                }
+            }
+        }
+        return false;
+    }
+
+    public static String hostHeader(HttpUrl httpUrl, boolean z) {
+        String host;
+        if (httpUrl.host().contains(CertificateUtil.DELIMITER)) {
+            host = v8.i.d + httpUrl.host() + v8.i.e;
+        } else {
+            host = httpUrl.host();
+        }
+        if (!z && httpUrl.port() == HttpUrl.defaultPort(httpUrl.scheme())) {
+            return host;
+        }
+        return host + CertificateUtil.DELIMITER + httpUrl.port();
+    }
+
+    public static boolean isAndroidGetsocknameError(AssertionError assertionError) {
+        return (assertionError.getCause() == null || assertionError.getMessage() == null || !assertionError.getMessage().contains("getsockname failed")) ? false : true;
+    }
+
+    public static int indexOf(Comparator<String> comparator, String[] strArr, String str) {
+        int length = strArr.length;
+        for (int i = 0; i < length; i++) {
+            if (comparator.compare(strArr[i], str) == 0) {
+                return i;
+            }
+        }
+        return -1;
+    }
+
+    public static String[] concat(String[] strArr, String str) {
+        int length = strArr.length;
+        String[] strArr2 = new String[length + 1];
+        System.arraycopy(strArr, 0, strArr2, 0, strArr.length);
+        strArr2[length] = str;
+        return strArr2;
+    }
+
+    public static int skipLeadingAsciiWhitespace(String str, int i, int i2) {
+        while (i < i2) {
+            char charAt = str.charAt(i);
+            if (charAt != '\t' && charAt != '\n' && charAt != '\f' && charAt != '\r' && charAt != ' ') {
+                return i;
+            }
+            i++;
+        }
+        return i2;
+    }
+
+    public static int skipTrailingAsciiWhitespace(String str, int i, int i2) {
+        for (int i3 = i2 - 1; i3 >= i; i3--) {
+            char charAt = str.charAt(i3);
+            if (charAt != '\t' && charAt != '\n' && charAt != '\f' && charAt != '\r' && charAt != ' ') {
+                return i3 + 1;
+            }
+        }
+        return i;
+    }
+
+    public static String trimSubstring(String str, int i, int i2) {
+        int skipLeadingAsciiWhitespace = skipLeadingAsciiWhitespace(str, i, i2);
+        return str.substring(skipLeadingAsciiWhitespace, skipTrailingAsciiWhitespace(str, skipLeadingAsciiWhitespace, i2));
+    }
+
+    public static int delimiterOffset(String str, int i, int i2, String str2) {
+        while (i < i2) {
+            if (str2.indexOf(str.charAt(i)) != -1) {
+                return i;
+            }
+            i++;
+        }
+        return i2;
+    }
+
+    public static int delimiterOffset(String str, int i, int i2, char c) {
+        while (i < i2) {
+            if (str.charAt(i) == c) {
+                return i;
+            }
+            i++;
+        }
+        return i2;
+    }
+
+    public static String canonicalizeHost(String str) {
+        InetAddress decodeIpv6;
+        if (str.contains(CertificateUtil.DELIMITER)) {
+            if (str.startsWith(v8.i.d) && str.endsWith(v8.i.e)) {
+                decodeIpv6 = decodeIpv6(str, 1, str.length() - 1);
+            } else {
+                decodeIpv6 = decodeIpv6(str, 0, str.length());
+            }
+            if (decodeIpv6 == null) {
+                return null;
+            }
+            byte[] address = decodeIpv6.getAddress();
+            if (address.length == 16) {
+                return inet6AddressToAscii(address);
+            }
+            throw new AssertionError("Invalid IPv6 address: '" + str + "'");
+        }
+        try {
+            String lowerCase = IDN.toASCII(str).toLowerCase(Locale.US);
+            if (lowerCase.isEmpty()) {
+                return null;
+            }
+            if (containsInvalidHostnameAsciiCodes(lowerCase)) {
+                return null;
+            }
+            return lowerCase;
+        } catch (IllegalArgumentException unused) {
+            return null;
+        }
+    }
+
+    private static boolean containsInvalidHostnameAsciiCodes(String str) {
+        for (int i = 0; i < str.length(); i++) {
+            char charAt = str.charAt(i);
+            if (charAt <= 31 || charAt >= 127 || " #%/:?@[\\]".indexOf(charAt) != -1) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public static int indexOfControlOrNonAscii(String str) {
+        int length = str.length();
+        for (int i = 0; i < length; i++) {
+            char charAt = str.charAt(i);
+            if (charAt <= 31 || charAt >= 127) {
+                return i;
+            }
+        }
+        return -1;
+    }
+
+    public static boolean verifyAsIpAddress(String str) {
+        return VERIFY_AS_IP_ADDRESS.matcher(str).matches();
+    }
+
+    public static String format(String str, Object... objArr) {
+        return String.format(Locale.US, str, objArr);
+    }
+
+    public static Charset bomAwareCharset(BufferedSource bufferedSource, Charset charset) throws IOException {
+        if (bufferedSource.rangeEquals(0L, UTF_8_BOM)) {
+            bufferedSource.skip(r0.size());
+            return UTF_8;
+        }
+        if (bufferedSource.rangeEquals(0L, UTF_16_BE_BOM)) {
+            bufferedSource.skip(r0.size());
+            return UTF_16_BE;
+        }
+        if (bufferedSource.rangeEquals(0L, UTF_16_LE_BOM)) {
+            bufferedSource.skip(r0.size());
+            return UTF_16_LE;
+        }
+        if (bufferedSource.rangeEquals(0L, UTF_32_BE_BOM)) {
+            bufferedSource.skip(r0.size());
+            return UTF_32_BE;
+        }
+        if (!bufferedSource.rangeEquals(0L, UTF_32_LE_BOM)) {
+            return charset;
+        }
+        bufferedSource.skip(r0.size());
+        return UTF_32_LE;
+    }
+
+    public static int checkDuration(String str, long j, TimeUnit timeUnit) {
+        if (j < 0) {
+            throw new IllegalArgumentException(str + " < 0");
+        }
+        if (timeUnit == null) {
+            throw new NullPointerException("unit == null");
+        }
+        long millis = timeUnit.toMillis(j);
+        if (millis > 2147483647L) {
+            throw new IllegalArgumentException(str + " too large.");
+        }
+        if (millis != 0 || j <= 0) {
+            return (int) millis;
+        }
+        throw new IllegalArgumentException(str + " too small.");
+    }
+
+    public static AssertionError assertionError(String str, Exception exc) {
+        AssertionError assertionError = new AssertionError(str);
+        try {
+            assertionError.initCause(exc);
+        } catch (IllegalStateException unused) {
+        }
+        return assertionError;
+    }
+
+    /* JADX WARN: Code restructure failed: missing block: B:25:0x0078, code lost:
+    
+        return null;
+     */
+    /* JADX WARN: Removed duplicated region for block: B:15:0x004f  */
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    private static java.net.InetAddress decodeIpv6(java.lang.String r12, int r13, int r14) {
+        /*
+            r0 = 16
+            byte[] r1 = new byte[r0]
+            r2 = 0
+            r3 = -1
+            r4 = r2
+            r5 = r3
+            r6 = r5
+        L9:
+            r7 = 0
+            if (r13 >= r14) goto L79
+            if (r4 != r0) goto Lf
+            return r7
+        Lf:
+            int r8 = r13 + 2
+            r9 = 2
+            if (r8 > r14) goto L27
+            java.lang.String r10 = "::"
+            boolean r10 = r12.regionMatches(r13, r10, r2, r9)
+            if (r10 == 0) goto L27
+            if (r5 == r3) goto L1f
+            return r7
+        L1f:
+            int r4 = r4 + 2
+            r5 = r4
+            if (r8 != r14) goto L25
+            goto L79
+        L25:
+            r6 = r8
+            goto L4b
+        L27:
+            if (r4 == 0) goto L34
+            java.lang.String r8 = ":"
+            r10 = 1
+            boolean r8 = r12.regionMatches(r13, r8, r2, r10)
+            if (r8 == 0) goto L36
+            int r13 = r13 + 1
+        L34:
+            r6 = r13
+            goto L4b
+        L36:
+            java.lang.String r8 = "."
+            boolean r13 = r12.regionMatches(r13, r8, r2, r10)
+            if (r13 == 0) goto L4a
+            int r13 = r4 + (-2)
+            boolean r12 = decodeIpv4Suffix(r12, r6, r14, r1, r13)
+            if (r12 != 0) goto L47
+            return r7
+        L47:
+            int r4 = r4 + 2
+            goto L79
+        L4a:
+            return r7
+        L4b:
+            r8 = r2
+            r13 = r6
+        L4d:
+            if (r13 >= r14) goto L60
+            char r10 = r12.charAt(r13)
+            int r10 = decodeHexDigit(r10)
+            if (r10 != r3) goto L5a
+            goto L60
+        L5a:
+            int r8 = r8 << 4
+            int r8 = r8 + r10
+            int r13 = r13 + 1
+            goto L4d
+        L60:
+            int r10 = r13 - r6
+            if (r10 == 0) goto L78
+            r11 = 4
+            if (r10 <= r11) goto L68
+            goto L78
+        L68:
+            int r7 = r4 + 1
+            int r10 = r8 >>> 8
+            r10 = r10 & 255(0xff, float:3.57E-43)
+            byte r10 = (byte) r10
+            r1[r4] = r10
+            int r4 = r4 + r9
+            r8 = r8 & 255(0xff, float:3.57E-43)
+            byte r8 = (byte) r8
+            r1[r7] = r8
+            goto L9
+        L78:
+            return r7
+        L79:
+            if (r4 == r0) goto L8a
+            if (r5 != r3) goto L7e
+            return r7
+        L7e:
+            int r12 = r4 - r5
+            int r13 = 16 - r12
+            java.lang.System.arraycopy(r1, r5, r1, r13, r12)
+            int r0 = r0 - r4
+            int r0 = r0 + r5
+            java.util.Arrays.fill(r1, r5, r0, r2)
+        L8a:
+            java.net.InetAddress r12 = java.net.InetAddress.getByAddress(r1)     // Catch: java.net.UnknownHostException -> L8f
+            return r12
+        L8f:
+            java.lang.AssertionError r12 = new java.lang.AssertionError
+            r12.<init>()
+            throw r12
+        */
+        throw new UnsupportedOperationException("Method not decompiled: com.mbridge.msdk.thrid.okhttp.internal.Util.decodeIpv6(java.lang.String, int, int):java.net.InetAddress");
+    }
+
+    private static boolean decodeIpv4Suffix(String str, int i, int i2, byte[] bArr, int i3) {
+        int i4 = i3;
+        while (i < i2) {
+            if (i4 == bArr.length) {
+                return false;
+            }
+            if (i4 != i3) {
+                if (str.charAt(i) != '.') {
+                    return false;
+                }
+                i++;
+            }
+            int i5 = i;
+            int i6 = 0;
+            while (i5 < i2) {
+                char charAt = str.charAt(i5);
+                if (charAt < '0' || charAt > '9') {
+                    break;
+                }
+                if ((i6 == 0 && i != i5) || (i6 = ((i6 * 10) + charAt) - 48) > 255) {
+                    return false;
+                }
+                i5++;
+            }
+            if (i5 - i == 0) {
+                return false;
+            }
+            bArr[i4] = (byte) i6;
+            i4++;
+            i = i5;
+        }
+        return i4 == i3 + 4;
+    }
+
+    private static String inet6AddressToAscii(byte[] bArr) {
+        int i = -1;
+        int i2 = 0;
+        int i3 = 0;
+        int i4 = 0;
+        while (i3 < bArr.length) {
+            int i5 = i3;
+            while (i5 < 16 && bArr[i5] == 0 && bArr[i5 + 1] == 0) {
+                i5 += 2;
+            }
+            int i6 = i5 - i3;
+            if (i6 > i4 && i6 >= 4) {
+                i = i3;
+                i4 = i6;
+            }
+            i3 = i5 + 2;
+        }
+        Buffer buffer = new Buffer();
+        while (i2 < bArr.length) {
+            if (i2 == i) {
+                buffer.writeByte(58);
+                i2 += i4;
+                if (i2 == 16) {
+                    buffer.writeByte(58);
+                }
+            } else {
+                if (i2 > 0) {
+                    buffer.writeByte(58);
+                }
+                buffer.writeHexadecimalUnsignedLong(((bArr[i2] & 255) << 8) | (bArr[i2 + 1] & 255));
+                i2 += 2;
+            }
+        }
+        return buffer.readUtf8();
+    }
+
+    public static X509TrustManager platformTrustManager() {
+        try {
+            TrustManagerFactory trustManagerFactory = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
+            trustManagerFactory.init((KeyStore) null);
+            TrustManager[] trustManagers = trustManagerFactory.getTrustManagers();
+            if (trustManagers.length == 1) {
+                TrustManager trustManager = trustManagers[0];
+                if (trustManager instanceof X509TrustManager) {
+                    return (X509TrustManager) trustManager;
+                }
+            }
+            throw new IllegalStateException("Unexpected default trust managers:" + Arrays.toString(trustManagers));
+        } catch (GeneralSecurityException e) {
+            throw assertionError("No System TLS", e);
+        }
+    }
+
+    public static Headers toHeaders(List<Header> list) {
+        Headers.Builder builder = new Headers.Builder();
+        for (Header header : list) {
+            Internal.instance.addLenient(builder, header.name.utf8(), header.value.utf8());
+        }
+        return builder.build();
+    }
+}

decompiled/sources/com/mbridge/msdk/thrid/okhttp/internal/Version.java

@@ -0,0 +1,11 @@
+package com.mbridge.msdk.thrid.okhttp.internal;
+
+/* loaded from: classes4.dex */
+public final class Version {
+    public static String userAgent() {
+        return "okhttp/3.12.13";
+    }
+
+    private Version() {
+    }
+}

decompiled/sources/com/mbridge/msdk/thrid/okhttp/internal/annotations/EverythingIsNonNull.java

@@ -0,0 +1,11 @@
+package com.mbridge.msdk.thrid.okhttp.internal.annotations;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+@Documented
+@Retention(RetentionPolicy.RUNTIME)
+/* loaded from: classes4.dex */
+public @interface EverythingIsNonNull {
+}

decompiled/sources/com/mbridge/msdk/thrid/okhttp/internal/cache/CacheInterceptor.java

@@ -0,0 +1,169 @@
+package com.mbridge.msdk.thrid.okhttp.internal.cache;
+
+import com.mbridge.msdk.thrid.okhttp.Headers;
+import com.mbridge.msdk.thrid.okhttp.Interceptor;
+import com.mbridge.msdk.thrid.okhttp.Protocol;
+import com.mbridge.msdk.thrid.okhttp.Request;
+import com.mbridge.msdk.thrid.okhttp.Response;
+import com.mbridge.msdk.thrid.okhttp.internal.Internal;
+import com.mbridge.msdk.thrid.okhttp.internal.Util;
+import com.mbridge.msdk.thrid.okhttp.internal.cache.CacheStrategy;
+import com.mbridge.msdk.thrid.okhttp.internal.http.HttpHeaders;
+import com.mbridge.msdk.thrid.okhttp.internal.http.HttpMethod;
+import com.mbridge.msdk.thrid.okhttp.internal.http.RealResponseBody;
+import com.mbridge.msdk.thrid.okio.Buffer;
+import com.mbridge.msdk.thrid.okio.BufferedSink;
+import com.mbridge.msdk.thrid.okio.BufferedSource;
+import com.mbridge.msdk.thrid.okio.Okio;
+import com.mbridge.msdk.thrid.okio.Sink;
+import com.mbridge.msdk.thrid.okio.Source;
+import com.mbridge.msdk.thrid.okio.Timeout;
+import java.io.IOException;
+import java.util.concurrent.TimeUnit;
+import org.apache.http.HttpStatus;
+import org.apache.http.auth.AUTH;
+import org.apache.http.protocol.HTTP;
+
+/* loaded from: classes4.dex */
+public final class CacheInterceptor implements Interceptor {
+    final InternalCache cache;
+
+    public CacheInterceptor(InternalCache internalCache) {
+        this.cache = internalCache;
+    }
+
+    @Override // com.mbridge.msdk.thrid.okhttp.Interceptor
+    public Response intercept(Interceptor.Chain chain) throws IOException {
+        InternalCache internalCache = this.cache;
+        Response response = internalCache != null ? internalCache.get(chain.request()) : null;
+        CacheStrategy cacheStrategy = new CacheStrategy.Factory(System.currentTimeMillis(), chain.request(), response).get();
+        Request request = cacheStrategy.networkRequest;
+        Response response2 = cacheStrategy.cacheResponse;
+        InternalCache internalCache2 = this.cache;
+        if (internalCache2 != null) {
+            internalCache2.trackResponse(cacheStrategy);
+        }
+        if (response != null && response2 == null) {
+            Util.closeQuietly(response.body());
+        }
+        if (request == null && response2 == null) {
+            return new Response.Builder().request(chain.request()).protocol(Protocol.HTTP_1_1).code(HttpStatus.SC_GATEWAY_TIMEOUT).message("Unsatisfiable Request (only-if-cached)").body(Util.EMPTY_RESPONSE).sentRequestAtMillis(-1L).receivedResponseAtMillis(System.currentTimeMillis()).build();
+        }
+        if (request == null) {
+            return response2.newBuilder().cacheResponse(stripBody(response2)).build();
+        }
+        try {
+            Response proceed = chain.proceed(request);
+            if (proceed == null && response != null) {
+            }
+            if (response2 != null) {
+                if (proceed.code() == 304) {
+                    Response build = response2.newBuilder().headers(combine(response2.headers(), proceed.headers())).sentRequestAtMillis(proceed.sentRequestAtMillis()).receivedResponseAtMillis(proceed.receivedResponseAtMillis()).cacheResponse(stripBody(response2)).networkResponse(stripBody(proceed)).build();
+                    proceed.body().close();
+                    this.cache.trackConditionalCacheHit();
+                    this.cache.update(response2, build);
+                    return build;
+                }
+                Util.closeQuietly(response2.body());
+            }
+            Response build2 = proceed.newBuilder().cacheResponse(stripBody(response2)).networkResponse(stripBody(proceed)).build();
+            if (this.cache != null) {
+                if (HttpHeaders.hasBody(build2) && CacheStrategy.isCacheable(build2, request)) {
+                    return cacheWritingResponse(this.cache.put(build2), build2);
+                }
+                if (HttpMethod.invalidatesCache(request.method())) {
+                    try {
+                        this.cache.remove(request);
+                    } catch (IOException unused) {
+                    }
+                }
+            }
+            return build2;
+        } finally {
+            if (response != null) {
+                Util.closeQuietly(response.body());
+            }
+        }
+    }
+
+    private static Response stripBody(Response response) {
+        return (response == null || response.body() == null) ? response : response.newBuilder().body(null).build();
+    }
+
+    private Response cacheWritingResponse(final CacheRequest cacheRequest, Response response) throws IOException {
+        Sink body;
+        if (cacheRequest == null || (body = cacheRequest.body()) == null) {
+            return response;
+        }
+        final BufferedSource source = response.body().source();
+        final BufferedSink buffer = Okio.buffer(body);
+        return response.newBuilder().body(new RealResponseBody(response.header("Content-Type"), response.body().contentLength(), Okio.buffer(new Source() { // from class: com.mbridge.msdk.thrid.okhttp.internal.cache.CacheInterceptor.1
+            boolean cacheRequestClosed;
+
+            @Override // com.mbridge.msdk.thrid.okio.Source
+            public long read(Buffer buffer2, long j) throws IOException {
+                try {
+                    long read = source.read(buffer2, j);
+                    if (read != -1) {
+                        buffer2.copyTo(buffer.buffer(), buffer2.size() - read, read);
+                        buffer.emitCompleteSegments();
+                        return read;
+                    }
+                    if (!this.cacheRequestClosed) {
+                        this.cacheRequestClosed = true;
+                        buffer.close();
+                    }
+                    return -1L;
+                } catch (IOException e) {
+                    if (!this.cacheRequestClosed) {
+                        this.cacheRequestClosed = true;
+                        cacheRequest.abort();
+                    }
+                    throw e;
+                }
+            }
+
+            @Override // com.mbridge.msdk.thrid.okio.Source
+            public Timeout timeout() {
+                return source.timeout();
+            }
+
+            @Override // com.mbridge.msdk.thrid.okio.Source, java.io.Closeable, java.lang.AutoCloseable
+            public void close() throws IOException {
+                if (!this.cacheRequestClosed && !Util.discard(this, 100, TimeUnit.MILLISECONDS)) {
+                    this.cacheRequestClosed = true;
+                    cacheRequest.abort();
+                }
+                source.close();
+            }
+        }))).build();
+    }
+
+    private static Headers combine(Headers headers, Headers headers2) {
+        Headers.Builder builder = new Headers.Builder();
+        int size = headers.size();
+        for (int i = 0; i < size; i++) {
+            String name = headers.name(i);
+            String value = headers.value(i);
+            if ((!"Warning".equalsIgnoreCase(name) || !value.startsWith("1")) && (isContentSpecificHeader(name) || !isEndToEnd(name) || headers2.get(name) == null)) {
+                Internal.instance.addLenient(builder, name, value);
+            }
+        }
+        int size2 = headers2.size();
+        for (int i2 = 0; i2 < size2; i2++) {
+            String name2 = headers2.name(i2);
+            if (!isContentSpecificHeader(name2) && isEndToEnd(name2)) {
+                Internal.instance.addLenient(builder, name2, headers2.value(i2));
+            }
+        }
+        return builder.build();
+    }
+
+    public static boolean isEndToEnd(String str) {
+        return (HTTP.CONN_DIRECTIVE.equalsIgnoreCase(str) || HTTP.CONN_KEEP_ALIVE.equalsIgnoreCase(str) || AUTH.PROXY_AUTH.equalsIgnoreCase(str) || AUTH.PROXY_AUTH_RESP.equalsIgnoreCase(str) || "TE".equalsIgnoreCase(str) || "Trailers".equalsIgnoreCase(str) || HTTP.TRANSFER_ENCODING.equalsIgnoreCase(str) || "Upgrade".equalsIgnoreCase(str)) ? false : true;
+    }
+
+    public static boolean isContentSpecificHeader(String str) {
+        return HTTP.CONTENT_LEN.equalsIgnoreCase(str) || HTTP.CONTENT_ENCODING.equalsIgnoreCase(str) || "Content-Type".equalsIgnoreCase(str);
+    }
+}

decompiled/sources/com/mbridge/msdk/thrid/okhttp/internal/cache/CacheRequest.java

@@ -0,0 +1,11 @@
+package com.mbridge.msdk.thrid.okhttp.internal.cache;
+
+import com.mbridge.msdk.thrid.okio.Sink;
+import java.io.IOException;
+
+/* loaded from: classes4.dex */
+public interface CacheRequest {
+    void abort();
+
+    Sink body() throws IOException;
+}

decompiled/sources/com/mbridge/msdk/thrid/okhttp/internal/cache/CacheStrategy.java

@@ -0,0 +1,246 @@
+package com.mbridge.msdk.thrid.okhttp.internal.cache;
+
+import com.mbridge.msdk.foundation.download.Command;
+import com.mbridge.msdk.thrid.okhttp.CacheControl;
+import com.mbridge.msdk.thrid.okhttp.Headers;
+import com.mbridge.msdk.thrid.okhttp.Request;
+import com.mbridge.msdk.thrid.okhttp.Response;
+import com.mbridge.msdk.thrid.okhttp.internal.Internal;
+import com.mbridge.msdk.thrid.okhttp.internal.http.HttpDate;
+import com.mbridge.msdk.thrid.okhttp.internal.http.HttpHeaders;
+import com.vungle.ads.internal.signals.SignalManager;
+import java.util.Date;
+import java.util.concurrent.TimeUnit;
+import org.apache.http.protocol.HTTP;
+
+/* loaded from: classes4.dex */
+public final class CacheStrategy {
+    public final Response cacheResponse;
+    public final Request networkRequest;
+
+    public CacheStrategy(Request request, Response response) {
+        this.networkRequest = request;
+        this.cacheResponse = response;
+    }
+
+    /* JADX WARN: Code restructure failed: missing block: B:31:0x0056, code lost:
+    
+        if (r3.cacheControl().isPrivate() == false) goto L33;
+     */
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    public static boolean isCacheable(com.mbridge.msdk.thrid.okhttp.Response r3, com.mbridge.msdk.thrid.okhttp.Request r4) {
+        /*
+            int r0 = r3.code()
+            r1 = 200(0xc8, float:2.8E-43)
+            r2 = 0
+            if (r0 == r1) goto L5a
+            r1 = 410(0x19a, float:5.75E-43)
+            if (r0 == r1) goto L5a
+            r1 = 414(0x19e, float:5.8E-43)
+            if (r0 == r1) goto L5a
+            r1 = 501(0x1f5, float:7.02E-43)
+            if (r0 == r1) goto L5a
+            r1 = 203(0xcb, float:2.84E-43)
+            if (r0 == r1) goto L5a
+            r1 = 204(0xcc, float:2.86E-43)
+            if (r0 == r1) goto L5a
+            r1 = 307(0x133, float:4.3E-43)
+            if (r0 == r1) goto L31
+            r1 = 308(0x134, float:4.32E-43)
+            if (r0 == r1) goto L5a
+            r1 = 404(0x194, float:5.66E-43)
+            if (r0 == r1) goto L5a
+            r1 = 405(0x195, float:5.68E-43)
+            if (r0 == r1) goto L5a
+            switch(r0) {
+                case 300: goto L5a;
+                case 301: goto L5a;
+                case 302: goto L31;
+                default: goto L30;
+            }
+        L30:
+            goto L59
+        L31:
+            java.lang.String r0 = "Expires"
+            java.lang.String r0 = r3.header(r0)
+            if (r0 != 0) goto L5a
+            com.mbridge.msdk.thrid.okhttp.CacheControl r0 = r3.cacheControl()
+            int r0 = r0.maxAgeSeconds()
+            r1 = -1
+            if (r0 != r1) goto L5a
+            com.mbridge.msdk.thrid.okhttp.CacheControl r0 = r3.cacheControl()
+            boolean r0 = r0.isPublic()
+            if (r0 != 0) goto L5a
+            com.mbridge.msdk.thrid.okhttp.CacheControl r0 = r3.cacheControl()
+            boolean r0 = r0.isPrivate()
+            if (r0 == 0) goto L59
+            goto L5a
+        L59:
+            return r2
+        L5a:
+            com.mbridge.msdk.thrid.okhttp.CacheControl r3 = r3.cacheControl()
+            boolean r3 = r3.noStore()
+            if (r3 != 0) goto L6f
+            com.mbridge.msdk.thrid.okhttp.CacheControl r3 = r4.cacheControl()
+            boolean r3 = r3.noStore()
+            if (r3 != 0) goto L6f
+            r2 = 1
+        L6f:
+            return r2
+        */
+        throw new UnsupportedOperationException("Method not decompiled: com.mbridge.msdk.thrid.okhttp.internal.cache.CacheStrategy.isCacheable(com.mbridge.msdk.thrid.okhttp.Response, com.mbridge.msdk.thrid.okhttp.Request):boolean");
+    }
+
+    public static class Factory {
+        private int ageSeconds;
+        final Response cacheResponse;
+        private String etag;
+        private Date expires;
+        private Date lastModified;
+        private String lastModifiedString;
+        final long nowMillis;
+        private long receivedResponseMillis;
+        final Request request;
+        private long sentRequestMillis;
+        private Date servedDate;
+        private String servedDateString;
+
+        public Factory(long j, Request request, Response response) {
+            this.ageSeconds = -1;
+            this.nowMillis = j;
+            this.request = request;
+            this.cacheResponse = response;
+            if (response != null) {
+                this.sentRequestMillis = response.sentRequestAtMillis();
+                this.receivedResponseMillis = response.receivedResponseAtMillis();
+                Headers headers = response.headers();
+                int size = headers.size();
+                for (int i = 0; i < size; i++) {
+                    String name = headers.name(i);
+                    String value = headers.value(i);
+                    if (HTTP.DATE_HEADER.equalsIgnoreCase(name)) {
+                        this.servedDate = HttpDate.parse(value);
+                        this.servedDateString = value;
+                    } else if ("Expires".equalsIgnoreCase(name)) {
+                        this.expires = HttpDate.parse(value);
+                    } else if ("Last-Modified".equalsIgnoreCase(name)) {
+                        this.lastModified = HttpDate.parse(value);
+                        this.lastModifiedString = value;
+                    } else if (Command.HTTP_HEADER_ETAG.equalsIgnoreCase(name)) {
+                        this.etag = value;
+                    } else if ("Age".equalsIgnoreCase(name)) {
+                        this.ageSeconds = HttpHeaders.parseSeconds(value, -1);
+                    }
+                }
+            }
+        }
+
+        public CacheStrategy get() {
+            CacheStrategy candidate = getCandidate();
+            return (candidate.networkRequest == null || !this.request.cacheControl().onlyIfCached()) ? candidate : new CacheStrategy(null, null);
+        }
+
+        private CacheStrategy getCandidate() {
+            String str;
+            if (this.cacheResponse == null) {
+                return new CacheStrategy(this.request, null);
+            }
+            if (this.request.isHttps() && this.cacheResponse.handshake() == null) {
+                return new CacheStrategy(this.request, null);
+            }
+            if (!CacheStrategy.isCacheable(this.cacheResponse, this.request)) {
+                return new CacheStrategy(this.request, null);
+            }
+            CacheControl cacheControl = this.request.cacheControl();
+            if (cacheControl.noCache() || hasConditions(this.request)) {
+                return new CacheStrategy(this.request, null);
+            }
+            CacheControl cacheControl2 = this.cacheResponse.cacheControl();
+            long cacheResponseAge = cacheResponseAge();
+            long computeFreshnessLifetime = computeFreshnessLifetime();
+            if (cacheControl.maxAgeSeconds() != -1) {
+                computeFreshnessLifetime = Math.min(computeFreshnessLifetime, TimeUnit.SECONDS.toMillis(cacheControl.maxAgeSeconds()));
+            }
+            long j = 0;
+            long millis = cacheControl.minFreshSeconds() != -1 ? TimeUnit.SECONDS.toMillis(cacheControl.minFreshSeconds()) : 0L;
+            if (!cacheControl2.mustRevalidate() && cacheControl.maxStaleSeconds() != -1) {
+                j = TimeUnit.SECONDS.toMillis(cacheControl.maxStaleSeconds());
+            }
+            if (!cacheControl2.noCache()) {
+                long j2 = millis + cacheResponseAge;
+                if (j2 < j + computeFreshnessLifetime) {
+                    Response.Builder newBuilder = this.cacheResponse.newBuilder();
+                    if (j2 >= computeFreshnessLifetime) {
+                        newBuilder.addHeader("Warning", "110 HttpURLConnection \"Response is stale\"");
+                    }
+                    if (cacheResponseAge > SignalManager.TWENTY_FOUR_HOURS_MILLIS && isFreshnessLifetimeHeuristic()) {
+                        newBuilder.addHeader("Warning", "113 HttpURLConnection \"Heuristic expiration\"");
+                    }
+                    return new CacheStrategy(null, newBuilder.build());
+                }
+            }
+            String str2 = this.etag;
+            if (str2 != null) {
+                str = "If-None-Match";
+            } else {
+                if (this.lastModified != null) {
+                    str2 = this.lastModifiedString;
+                } else {
+                    if (this.servedDate == null) {
+                        return new CacheStrategy(this.request, null);
+                    }
+                    str2 = this.servedDateString;
+                }
+                str = "If-Modified-Since";
+            }
+            Headers.Builder newBuilder2 = this.request.headers().newBuilder();
+            Internal.instance.addLenient(newBuilder2, str, str2);
+            return new CacheStrategy(this.request.newBuilder().headers(newBuilder2.build()).build(), this.cacheResponse);
+        }
+
+        private long computeFreshnessLifetime() {
+            if (this.cacheResponse.cacheControl().maxAgeSeconds() != -1) {
+                return TimeUnit.SECONDS.toMillis(r0.maxAgeSeconds());
+            }
+            if (this.expires != null) {
+                Date date = this.servedDate;
+                long time = this.expires.getTime() - (date != null ? date.getTime() : this.receivedResponseMillis);
+                if (time > 0) {
+                    return time;
+                }
+                return 0L;
+            }
+            if (this.lastModified == null || this.cacheResponse.request().url().query() != null) {
+                return 0L;
+            }
+            Date date2 = this.servedDate;
+            long time2 = (date2 != null ? date2.getTime() : this.sentRequestMillis) - this.lastModified.getTime();
+            if (time2 > 0) {
+                return time2 / 10;
+            }
+            return 0L;
+        }
+
+        private long cacheResponseAge() {
+            Date date = this.servedDate;
+            long max = date != null ? Math.max(0L, this.receivedResponseMillis - date.getTime()) : 0L;
+            int i = this.ageSeconds;
+            if (i != -1) {
+                max = Math.max(max, TimeUnit.SECONDS.toMillis(i));
+            }
+            long j = this.receivedResponseMillis;
+            return max + (j - this.sentRequestMillis) + (this.nowMillis - j);
+        }
+
+        private boolean isFreshnessLifetimeHeuristic() {
+            return this.cacheResponse.cacheControl().maxAgeSeconds() == -1 && this.expires == null;
+        }
+
+        private static boolean hasConditions(Request request) {
+            return (request.header("If-Modified-Since") == null && request.header("If-None-Match") == null) ? false : true;
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/thrid/okhttp/internal/cache/DiskLruCache.java

@@ -0,0 +1,855 @@
+package com.mbridge.msdk.thrid.okhttp.internal.cache;
+
+import com.ironsource.v8;
+import com.mbridge.msdk.thrid.okhttp.internal.Util;
+import com.mbridge.msdk.thrid.okhttp.internal.io.FileSystem;
+import com.mbridge.msdk.thrid.okhttp.internal.platform.Platform;
+import com.mbridge.msdk.thrid.okio.BufferedSink;
+import com.mbridge.msdk.thrid.okio.BufferedSource;
+import com.mbridge.msdk.thrid.okio.Okio;
+import com.mbridge.msdk.thrid.okio.Sink;
+import com.mbridge.msdk.thrid.okio.Source;
+import java.io.Closeable;
+import java.io.EOFException;
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.Flushable;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Iterator;
+import java.util.LinkedHashMap;
+import java.util.NoSuchElementException;
+import java.util.concurrent.Executor;
+import java.util.concurrent.LinkedBlockingQueue;
+import java.util.concurrent.ThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;
+import java.util.regex.Pattern;
+
+/* loaded from: classes4.dex */
+public final class DiskLruCache implements Closeable, Flushable {
+    static final /* synthetic */ boolean $assertionsDisabled = false;
+    static final long ANY_SEQUENCE_NUMBER = -1;
+    private static final String CLEAN = "CLEAN";
+    private static final String DIRTY = "DIRTY";
+    static final String JOURNAL_FILE = "journal";
+    static final String JOURNAL_FILE_BACKUP = "journal.bkp";
+    static final String JOURNAL_FILE_TEMP = "journal.tmp";
+    static final Pattern LEGAL_KEY_PATTERN = Pattern.compile("[a-z0-9_-]{1,120}");
+    static final String MAGIC = "libcore.io.DiskLruCache";
+    private static final String READ = "READ";
+    private static final String REMOVE = "REMOVE";
+    static final String VERSION_1 = "1";
+    private final int appVersion;
+    boolean closed;
+    final File directory;
+    private final Executor executor;
+    final FileSystem fileSystem;
+    boolean hasJournalErrors;
+    boolean initialized;
+    private final File journalFile;
+    private final File journalFileBackup;
+    private final File journalFileTmp;
+    BufferedSink journalWriter;
+    private long maxSize;
+    boolean mostRecentRebuildFailed;
+    boolean mostRecentTrimFailed;
+    int redundantOpCount;
+    final int valueCount;
+    private long size = 0;
+    final LinkedHashMap<String, Entry> lruEntries = new LinkedHashMap<>(0, 0.75f, true);
+    private long nextSequenceNumber = 0;
+    private final Runnable cleanupRunnable = new Runnable() { // from class: com.mbridge.msdk.thrid.okhttp.internal.cache.DiskLruCache.1
+        @Override // java.lang.Runnable
+        public void run() {
+            synchronized (DiskLruCache.this) {
+                DiskLruCache diskLruCache = DiskLruCache.this;
+                if ((!diskLruCache.initialized) || diskLruCache.closed) {
+                    return;
+                }
+                try {
+                    diskLruCache.trimToSize();
+                } catch (IOException unused) {
+                    DiskLruCache.this.mostRecentTrimFailed = true;
+                }
+                try {
+                    if (DiskLruCache.this.journalRebuildRequired()) {
+                        DiskLruCache.this.rebuildJournal();
+                        DiskLruCache.this.redundantOpCount = 0;
+                    }
+                } catch (IOException unused2) {
+                    DiskLruCache diskLruCache2 = DiskLruCache.this;
+                    diskLruCache2.mostRecentRebuildFailed = true;
+                    diskLruCache2.journalWriter = Okio.buffer(Okio.blackhole());
+                }
+            }
+        }
+    };
+
+    public File getDirectory() {
+        return this.directory;
+    }
+
+    public DiskLruCache(FileSystem fileSystem, File file, int i, int i2, long j, Executor executor) {
+        this.fileSystem = fileSystem;
+        this.directory = file;
+        this.appVersion = i;
+        this.journalFile = new File(file, JOURNAL_FILE);
+        this.journalFileTmp = new File(file, JOURNAL_FILE_TEMP);
+        this.journalFileBackup = new File(file, JOURNAL_FILE_BACKUP);
+        this.valueCount = i2;
+        this.maxSize = j;
+        this.executor = executor;
+    }
+
+    public synchronized void initialize() throws IOException {
+        try {
+            if (this.initialized) {
+                return;
+            }
+            if (this.fileSystem.exists(this.journalFileBackup)) {
+                if (this.fileSystem.exists(this.journalFile)) {
+                    this.fileSystem.delete(this.journalFileBackup);
+                } else {
+                    this.fileSystem.rename(this.journalFileBackup, this.journalFile);
+                }
+            }
+            if (this.fileSystem.exists(this.journalFile)) {
+                try {
+                    readJournal();
+                    processJournal();
+                    this.initialized = true;
+                    return;
+                } catch (IOException e) {
+                    Platform.get().log(5, "DiskLruCache " + this.directory + " is corrupt: " + e.getMessage() + ", removing", e);
+                    try {
+                        delete();
+                        this.closed = false;
+                    } catch (Throwable th) {
+                        this.closed = false;
+                        throw th;
+                    }
+                }
+            }
+            rebuildJournal();
+            this.initialized = true;
+        } catch (Throwable th2) {
+            throw th2;
+        }
+    }
+
+    public static DiskLruCache create(FileSystem fileSystem, File file, int i, int i2, long j) {
+        if (j <= 0) {
+            throw new IllegalArgumentException("maxSize <= 0");
+        }
+        if (i2 <= 0) {
+            throw new IllegalArgumentException("valueCount <= 0");
+        }
+        return new DiskLruCache(fileSystem, file, i, i2, j, new ThreadPoolExecutor(0, 1, 60L, TimeUnit.SECONDS, new LinkedBlockingQueue(), Util.threadFactory("OkHttp DiskLruCache", true)));
+    }
+
+    private void readJournal() throws IOException {
+        BufferedSource buffer = Okio.buffer(this.fileSystem.source(this.journalFile));
+        try {
+            String readUtf8LineStrict = buffer.readUtf8LineStrict();
+            String readUtf8LineStrict2 = buffer.readUtf8LineStrict();
+            String readUtf8LineStrict3 = buffer.readUtf8LineStrict();
+            String readUtf8LineStrict4 = buffer.readUtf8LineStrict();
+            String readUtf8LineStrict5 = buffer.readUtf8LineStrict();
+            if (!MAGIC.equals(readUtf8LineStrict) || !"1".equals(readUtf8LineStrict2) || !Integer.toString(this.appVersion).equals(readUtf8LineStrict3) || !Integer.toString(this.valueCount).equals(readUtf8LineStrict4) || !"".equals(readUtf8LineStrict5)) {
+                throw new IOException("unexpected journal header: [" + readUtf8LineStrict + ", " + readUtf8LineStrict2 + ", " + readUtf8LineStrict4 + ", " + readUtf8LineStrict5 + v8.i.e);
+            }
+            int i = 0;
+            while (true) {
+                try {
+                    readJournalLine(buffer.readUtf8LineStrict());
+                    i++;
+                } catch (EOFException unused) {
+                    this.redundantOpCount = i - this.lruEntries.size();
+                    if (!buffer.exhausted()) {
+                        rebuildJournal();
+                    } else {
+                        this.journalWriter = newJournalWriter();
+                    }
+                    Util.closeQuietly(buffer);
+                    return;
+                }
+            }
+        } catch (Throwable th) {
+            Util.closeQuietly(buffer);
+            throw th;
+        }
+    }
+
+    private BufferedSink newJournalWriter() throws FileNotFoundException {
+        return Okio.buffer(new FaultHidingSink(this.fileSystem.appendingSink(this.journalFile)) { // from class: com.mbridge.msdk.thrid.okhttp.internal.cache.DiskLruCache.2
+            static final /* synthetic */ boolean $assertionsDisabled = false;
+
+            @Override // com.mbridge.msdk.thrid.okhttp.internal.cache.FaultHidingSink
+            public void onException(IOException iOException) {
+                DiskLruCache.this.hasJournalErrors = true;
+            }
+        });
+    }
+
+    private void readJournalLine(String str) throws IOException {
+        String substring;
+        int indexOf = str.indexOf(32);
+        if (indexOf == -1) {
+            throw new IOException("unexpected journal line: " + str);
+        }
+        int i = indexOf + 1;
+        int indexOf2 = str.indexOf(32, i);
+        if (indexOf2 == -1) {
+            substring = str.substring(i);
+            if (indexOf == 6 && str.startsWith(REMOVE)) {
+                this.lruEntries.remove(substring);
+                return;
+            }
+        } else {
+            substring = str.substring(i, indexOf2);
+        }
+        Entry entry = this.lruEntries.get(substring);
+        if (entry == null) {
+            entry = new Entry(substring);
+            this.lruEntries.put(substring, entry);
+        }
+        if (indexOf2 != -1 && indexOf == 5 && str.startsWith(CLEAN)) {
+            String[] split = str.substring(indexOf2 + 1).split(" ");
+            entry.readable = true;
+            entry.currentEditor = null;
+            entry.setLengths(split);
+            return;
+        }
+        if (indexOf2 == -1 && indexOf == 5 && str.startsWith(DIRTY)) {
+            entry.currentEditor = new Editor(entry);
+            return;
+        }
+        if (indexOf2 == -1 && indexOf == 4 && str.startsWith(READ)) {
+            return;
+        }
+        throw new IOException("unexpected journal line: " + str);
+    }
+
+    private void processJournal() throws IOException {
+        this.fileSystem.delete(this.journalFileTmp);
+        Iterator<Entry> it = this.lruEntries.values().iterator();
+        while (it.hasNext()) {
+            Entry next = it.next();
+            int i = 0;
+            if (next.currentEditor == null) {
+                while (i < this.valueCount) {
+                    this.size += next.lengths[i];
+                    i++;
+                }
+            } else {
+                next.currentEditor = null;
+                while (i < this.valueCount) {
+                    this.fileSystem.delete(next.cleanFiles[i]);
+                    this.fileSystem.delete(next.dirtyFiles[i]);
+                    i++;
+                }
+                it.remove();
+            }
+        }
+    }
+
+    public synchronized void rebuildJournal() throws IOException {
+        try {
+            BufferedSink bufferedSink = this.journalWriter;
+            if (bufferedSink != null) {
+                bufferedSink.close();
+            }
+            BufferedSink buffer = Okio.buffer(this.fileSystem.sink(this.journalFileTmp));
+            try {
+                buffer.writeUtf8(MAGIC).writeByte(10);
+                buffer.writeUtf8("1").writeByte(10);
+                buffer.writeDecimalLong(this.appVersion).writeByte(10);
+                buffer.writeDecimalLong(this.valueCount).writeByte(10);
+                buffer.writeByte(10);
+                for (Entry entry : this.lruEntries.values()) {
+                    if (entry.currentEditor != null) {
+                        buffer.writeUtf8(DIRTY).writeByte(32);
+                        buffer.writeUtf8(entry.key);
+                        buffer.writeByte(10);
+                    } else {
+                        buffer.writeUtf8(CLEAN).writeByte(32);
+                        buffer.writeUtf8(entry.key);
+                        entry.writeLengths(buffer);
+                        buffer.writeByte(10);
+                    }
+                }
+                buffer.close();
+                if (this.fileSystem.exists(this.journalFile)) {
+                    this.fileSystem.rename(this.journalFile, this.journalFileBackup);
+                }
+                this.fileSystem.rename(this.journalFileTmp, this.journalFile);
+                this.fileSystem.delete(this.journalFileBackup);
+                this.journalWriter = newJournalWriter();
+                this.hasJournalErrors = false;
+                this.mostRecentRebuildFailed = false;
+            } catch (Throwable th) {
+                buffer.close();
+                throw th;
+            }
+        } catch (Throwable th2) {
+            throw th2;
+        }
+    }
+
+    public synchronized Snapshot get(String str) throws IOException {
+        initialize();
+        checkNotClosed();
+        validateKey(str);
+        Entry entry = this.lruEntries.get(str);
+        if (entry != null && entry.readable) {
+            Snapshot snapshot = entry.snapshot();
+            if (snapshot == null) {
+                return null;
+            }
+            this.redundantOpCount++;
+            this.journalWriter.writeUtf8(READ).writeByte(32).writeUtf8(str).writeByte(10);
+            if (journalRebuildRequired()) {
+                this.executor.execute(this.cleanupRunnable);
+            }
+            return snapshot;
+        }
+        return null;
+    }
+
+    public Editor edit(String str) throws IOException {
+        return edit(str, -1L);
+    }
+
+    public synchronized Editor edit(String str, long j) throws IOException {
+        initialize();
+        checkNotClosed();
+        validateKey(str);
+        Entry entry = this.lruEntries.get(str);
+        if (j != -1 && (entry == null || entry.sequenceNumber != j)) {
+            return null;
+        }
+        if (entry != null && entry.currentEditor != null) {
+            return null;
+        }
+        if (!this.mostRecentTrimFailed && !this.mostRecentRebuildFailed) {
+            this.journalWriter.writeUtf8(DIRTY).writeByte(32).writeUtf8(str).writeByte(10);
+            this.journalWriter.flush();
+            if (this.hasJournalErrors) {
+                return null;
+            }
+            if (entry == null) {
+                entry = new Entry(str);
+                this.lruEntries.put(str, entry);
+            }
+            Editor editor = new Editor(entry);
+            entry.currentEditor = editor;
+            return editor;
+        }
+        this.executor.execute(this.cleanupRunnable);
+        return null;
+    }
+
+    public synchronized long getMaxSize() {
+        return this.maxSize;
+    }
+
+    public synchronized void setMaxSize(long j) {
+        this.maxSize = j;
+        if (this.initialized) {
+            this.executor.execute(this.cleanupRunnable);
+        }
+    }
+
+    public synchronized long size() throws IOException {
+        initialize();
+        return this.size;
+    }
+
+    public synchronized void completeEdit(Editor editor, boolean z) throws IOException {
+        Entry entry = editor.entry;
+        if (entry.currentEditor != editor) {
+            throw new IllegalStateException();
+        }
+        if (z && !entry.readable) {
+            for (int i = 0; i < this.valueCount; i++) {
+                if (!editor.written[i]) {
+                    editor.abort();
+                    throw new IllegalStateException("Newly created entry didn't create value for index " + i);
+                }
+                if (!this.fileSystem.exists(entry.dirtyFiles[i])) {
+                    editor.abort();
+                    return;
+                }
+            }
+        }
+        for (int i2 = 0; i2 < this.valueCount; i2++) {
+            File file = entry.dirtyFiles[i2];
+            if (z) {
+                if (this.fileSystem.exists(file)) {
+                    File file2 = entry.cleanFiles[i2];
+                    this.fileSystem.rename(file, file2);
+                    long j = entry.lengths[i2];
+                    long size = this.fileSystem.size(file2);
+                    entry.lengths[i2] = size;
+                    this.size = (this.size - j) + size;
+                }
+            } else {
+                this.fileSystem.delete(file);
+            }
+        }
+        this.redundantOpCount++;
+        entry.currentEditor = null;
+        if (entry.readable | z) {
+            entry.readable = true;
+            this.journalWriter.writeUtf8(CLEAN).writeByte(32);
+            this.journalWriter.writeUtf8(entry.key);
+            entry.writeLengths(this.journalWriter);
+            this.journalWriter.writeByte(10);
+            if (z) {
+                long j2 = this.nextSequenceNumber;
+                this.nextSequenceNumber = 1 + j2;
+                entry.sequenceNumber = j2;
+            }
+        } else {
+            this.lruEntries.remove(entry.key);
+            this.journalWriter.writeUtf8(REMOVE).writeByte(32);
+            this.journalWriter.writeUtf8(entry.key);
+            this.journalWriter.writeByte(10);
+        }
+        this.journalWriter.flush();
+        if (this.size > this.maxSize || journalRebuildRequired()) {
+            this.executor.execute(this.cleanupRunnable);
+        }
+    }
+
+    public boolean journalRebuildRequired() {
+        int i = this.redundantOpCount;
+        return i >= 2000 && i >= this.lruEntries.size();
+    }
+
+    public synchronized boolean remove(String str) throws IOException {
+        initialize();
+        checkNotClosed();
+        validateKey(str);
+        Entry entry = this.lruEntries.get(str);
+        if (entry == null) {
+            return false;
+        }
+        boolean removeEntry = removeEntry(entry);
+        if (removeEntry && this.size <= this.maxSize) {
+            this.mostRecentTrimFailed = false;
+        }
+        return removeEntry;
+    }
+
+    public boolean removeEntry(Entry entry) throws IOException {
+        Editor editor = entry.currentEditor;
+        if (editor != null) {
+            editor.detach();
+        }
+        for (int i = 0; i < this.valueCount; i++) {
+            this.fileSystem.delete(entry.cleanFiles[i]);
+            long j = this.size;
+            long[] jArr = entry.lengths;
+            this.size = j - jArr[i];
+            jArr[i] = 0;
+        }
+        this.redundantOpCount++;
+        this.journalWriter.writeUtf8(REMOVE).writeByte(32).writeUtf8(entry.key).writeByte(10);
+        this.lruEntries.remove(entry.key);
+        if (journalRebuildRequired()) {
+            this.executor.execute(this.cleanupRunnable);
+        }
+        return true;
+    }
+
+    public synchronized boolean isClosed() {
+        return this.closed;
+    }
+
+    private synchronized void checkNotClosed() {
+        if (isClosed()) {
+            throw new IllegalStateException("cache is closed");
+        }
+    }
+
+    @Override // java.io.Flushable
+    public synchronized void flush() throws IOException {
+        if (this.initialized) {
+            checkNotClosed();
+            trimToSize();
+            this.journalWriter.flush();
+        }
+    }
+
+    @Override // java.io.Closeable, java.lang.AutoCloseable
+    public synchronized void close() throws IOException {
+        try {
+            if (this.initialized && !this.closed) {
+                for (Entry entry : (Entry[]) this.lruEntries.values().toArray(new Entry[this.lruEntries.size()])) {
+                    Editor editor = entry.currentEditor;
+                    if (editor != null) {
+                        editor.abort();
+                    }
+                }
+                trimToSize();
+                this.journalWriter.close();
+                this.journalWriter = null;
+                this.closed = true;
+                return;
+            }
+            this.closed = true;
+        } catch (Throwable th) {
+            throw th;
+        }
+    }
+
+    public void trimToSize() throws IOException {
+        while (this.size > this.maxSize) {
+            removeEntry(this.lruEntries.values().iterator().next());
+        }
+        this.mostRecentTrimFailed = false;
+    }
+
+    public void delete() throws IOException {
+        close();
+        this.fileSystem.deleteContents(this.directory);
+    }
+
+    public synchronized void evictAll() throws IOException {
+        try {
+            initialize();
+            for (Entry entry : (Entry[]) this.lruEntries.values().toArray(new Entry[this.lruEntries.size()])) {
+                removeEntry(entry);
+            }
+            this.mostRecentTrimFailed = false;
+        } catch (Throwable th) {
+            throw th;
+        }
+    }
+
+    private void validateKey(String str) {
+        if (LEGAL_KEY_PATTERN.matcher(str).matches()) {
+            return;
+        }
+        throw new IllegalArgumentException("keys must match regex [a-z0-9_-]{1,120}: \"" + str + "\"");
+    }
+
+    public synchronized Iterator<Snapshot> snapshots() throws IOException {
+        initialize();
+        return new Iterator<Snapshot>() { // from class: com.mbridge.msdk.thrid.okhttp.internal.cache.DiskLruCache.3
+            final Iterator<Entry> delegate;
+            Snapshot nextSnapshot;
+            Snapshot removeSnapshot;
+
+            {
+                this.delegate = new ArrayList(DiskLruCache.this.lruEntries.values()).iterator();
+            }
+
+            @Override // java.util.Iterator
+            public boolean hasNext() {
+                Snapshot snapshot;
+                if (this.nextSnapshot != null) {
+                    return true;
+                }
+                synchronized (DiskLruCache.this) {
+                    try {
+                        if (DiskLruCache.this.closed) {
+                            return false;
+                        }
+                        while (this.delegate.hasNext()) {
+                            Entry next = this.delegate.next();
+                            if (next.readable && (snapshot = next.snapshot()) != null) {
+                                this.nextSnapshot = snapshot;
+                                return true;
+                            }
+                        }
+                        return false;
+                    } catch (Throwable th) {
+                        throw th;
+                    }
+                }
+            }
+
+            /* JADX WARN: Can't rename method to resolve collision */
+            @Override // java.util.Iterator
+            public Snapshot next() {
+                if (!hasNext()) {
+                    throw new NoSuchElementException();
+                }
+                Snapshot snapshot = this.nextSnapshot;
+                this.removeSnapshot = snapshot;
+                this.nextSnapshot = null;
+                return snapshot;
+            }
+
+            @Override // java.util.Iterator
+            public void remove() {
+                Snapshot snapshot = this.removeSnapshot;
+                if (snapshot == null) {
+                    throw new IllegalStateException("remove() before next()");
+                }
+                try {
+                    DiskLruCache.this.remove(snapshot.key);
+                } catch (IOException unused) {
+                } catch (Throwable th) {
+                    this.removeSnapshot = null;
+                    throw th;
+                }
+                this.removeSnapshot = null;
+            }
+        };
+    }
+
+    public final class Snapshot implements Closeable {
+        private final String key;
+        private final long[] lengths;
+        private final long sequenceNumber;
+        private final Source[] sources;
+
+        public String key() {
+            return this.key;
+        }
+
+        public Snapshot(String str, long j, Source[] sourceArr, long[] jArr) {
+            this.key = str;
+            this.sequenceNumber = j;
+            this.sources = sourceArr;
+            this.lengths = jArr;
+        }
+
+        public Editor edit() throws IOException {
+            return DiskLruCache.this.edit(this.key, this.sequenceNumber);
+        }
+
+        public Source getSource(int i) {
+            return this.sources[i];
+        }
+
+        public long getLength(int i) {
+            return this.lengths[i];
+        }
+
+        @Override // java.io.Closeable, java.lang.AutoCloseable
+        public void close() {
+            for (Source source : this.sources) {
+                Util.closeQuietly(source);
+            }
+        }
+    }
+
+    public final class Editor {
+        private boolean done;
+        final Entry entry;
+        final boolean[] written;
+
+        public Editor(Entry entry) {
+            this.entry = entry;
+            this.written = entry.readable ? null : new boolean[DiskLruCache.this.valueCount];
+        }
+
+        public void detach() {
+            if (this.entry.currentEditor != this) {
+                return;
+            }
+            int i = 0;
+            while (true) {
+                DiskLruCache diskLruCache = DiskLruCache.this;
+                if (i < diskLruCache.valueCount) {
+                    try {
+                        diskLruCache.fileSystem.delete(this.entry.dirtyFiles[i]);
+                    } catch (IOException unused) {
+                    }
+                    i++;
+                } else {
+                    this.entry.currentEditor = null;
+                    return;
+                }
+            }
+        }
+
+        public Source newSource(int i) {
+            synchronized (DiskLruCache.this) {
+                try {
+                    if (this.done) {
+                        throw new IllegalStateException();
+                    }
+                    Entry entry = this.entry;
+                    if (!entry.readable || entry.currentEditor != this) {
+                        return null;
+                    }
+                    try {
+                        return DiskLruCache.this.fileSystem.source(entry.cleanFiles[i]);
+                    } catch (FileNotFoundException unused) {
+                        return null;
+                    }
+                } catch (Throwable th) {
+                    throw th;
+                }
+            }
+        }
+
+        public Sink newSink(int i) {
+            synchronized (DiskLruCache.this) {
+                try {
+                    if (this.done) {
+                        throw new IllegalStateException();
+                    }
+                    Entry entry = this.entry;
+                    if (entry.currentEditor != this) {
+                        return Okio.blackhole();
+                    }
+                    if (!entry.readable) {
+                        this.written[i] = true;
+                    }
+                    try {
+                        return new FaultHidingSink(DiskLruCache.this.fileSystem.sink(entry.dirtyFiles[i])) { // from class: com.mbridge.msdk.thrid.okhttp.internal.cache.DiskLruCache.Editor.1
+                            @Override // com.mbridge.msdk.thrid.okhttp.internal.cache.FaultHidingSink
+                            public void onException(IOException iOException) {
+                                synchronized (DiskLruCache.this) {
+                                    Editor.this.detach();
+                                }
+                            }
+                        };
+                    } catch (FileNotFoundException unused) {
+                        return Okio.blackhole();
+                    }
+                } catch (Throwable th) {
+                    throw th;
+                }
+            }
+        }
+
+        public void commit() throws IOException {
+            synchronized (DiskLruCache.this) {
+                try {
+                    if (this.done) {
+                        throw new IllegalStateException();
+                    }
+                    if (this.entry.currentEditor == this) {
+                        DiskLruCache.this.completeEdit(this, true);
+                    }
+                    this.done = true;
+                } catch (Throwable th) {
+                    throw th;
+                }
+            }
+        }
+
+        public void abort() throws IOException {
+            synchronized (DiskLruCache.this) {
+                try {
+                    if (this.done) {
+                        throw new IllegalStateException();
+                    }
+                    if (this.entry.currentEditor == this) {
+                        DiskLruCache.this.completeEdit(this, false);
+                    }
+                    this.done = true;
+                } catch (Throwable th) {
+                    throw th;
+                }
+            }
+        }
+
+        public void abortUnlessCommitted() {
+            synchronized (DiskLruCache.this) {
+                if (!this.done && this.entry.currentEditor == this) {
+                    try {
+                        DiskLruCache.this.completeEdit(this, false);
+                    } catch (IOException unused) {
+                    }
+                }
+            }
+        }
+    }
+
+    public final class Entry {
+        final File[] cleanFiles;
+        Editor currentEditor;
+        final File[] dirtyFiles;
+        final String key;
+        final long[] lengths;
+        boolean readable;
+        long sequenceNumber;
+
+        public Entry(String str) {
+            this.key = str;
+            int i = DiskLruCache.this.valueCount;
+            this.lengths = new long[i];
+            this.cleanFiles = new File[i];
+            this.dirtyFiles = new File[i];
+            StringBuilder sb = new StringBuilder(str);
+            sb.append('.');
+            int length = sb.length();
+            for (int i2 = 0; i2 < DiskLruCache.this.valueCount; i2++) {
+                sb.append(i2);
+                this.cleanFiles[i2] = new File(DiskLruCache.this.directory, sb.toString());
+                sb.append(".tmp");
+                this.dirtyFiles[i2] = new File(DiskLruCache.this.directory, sb.toString());
+                sb.setLength(length);
+            }
+        }
+
+        public void setLengths(String[] strArr) throws IOException {
+            if (strArr.length != DiskLruCache.this.valueCount) {
+                throw invalidLengths(strArr);
+            }
+            for (int i = 0; i < strArr.length; i++) {
+                try {
+                    this.lengths[i] = Long.parseLong(strArr[i]);
+                } catch (NumberFormatException unused) {
+                    throw invalidLengths(strArr);
+                }
+            }
+        }
+
+        public void writeLengths(BufferedSink bufferedSink) throws IOException {
+            for (long j : this.lengths) {
+                bufferedSink.writeByte(32).writeDecimalLong(j);
+            }
+        }
+
+        private IOException invalidLengths(String[] strArr) throws IOException {
+            throw new IOException("unexpected journal line: " + Arrays.toString(strArr));
+        }
+
+        public Snapshot snapshot() {
+            Source source;
+            if (!Thread.holdsLock(DiskLruCache.this)) {
+                throw new AssertionError();
+            }
+            Source[] sourceArr = new Source[DiskLruCache.this.valueCount];
+            long[] jArr = (long[]) this.lengths.clone();
+            int i = 0;
+            int i2 = 0;
+            while (true) {
+                try {
+                    DiskLruCache diskLruCache = DiskLruCache.this;
+                    if (i2 < diskLruCache.valueCount) {
+                        sourceArr[i2] = diskLruCache.fileSystem.source(this.cleanFiles[i2]);
+                        i2++;
+                    } else {
+                        return diskLruCache.new Snapshot(this.key, this.sequenceNumber, sourceArr, jArr);
+                    }
+                } catch (FileNotFoundException unused) {
+                    while (true) {
+                        DiskLruCache diskLruCache2 = DiskLruCache.this;
+                        if (i < diskLruCache2.valueCount && (source = sourceArr[i]) != null) {
+                            Util.closeQuietly(source);
+                            i++;
+                        } else {
+                            try {
+                                diskLruCache2.removeEntry(this);
+                                return null;
+                            } catch (IOException unused2) {
+                                return null;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/thrid/okhttp/internal/cache/FaultHidingSink.java

@@ -0,0 +1,58 @@
+package com.mbridge.msdk.thrid.okhttp.internal.cache;
+
+import com.mbridge.msdk.thrid.okio.Buffer;
+import com.mbridge.msdk.thrid.okio.ForwardingSink;
+import com.mbridge.msdk.thrid.okio.Sink;
+import java.io.IOException;
+
+/* loaded from: classes4.dex */
+class FaultHidingSink extends ForwardingSink {
+    private boolean hasErrors;
+
+    public void onException(IOException iOException) {
+    }
+
+    public FaultHidingSink(Sink sink) {
+        super(sink);
+    }
+
+    @Override // com.mbridge.msdk.thrid.okio.ForwardingSink, com.mbridge.msdk.thrid.okio.Sink
+    public void write(Buffer buffer, long j) throws IOException {
+        if (this.hasErrors) {
+            buffer.skip(j);
+            return;
+        }
+        try {
+            super.write(buffer, j);
+        } catch (IOException e) {
+            this.hasErrors = true;
+            onException(e);
+        }
+    }
+
+    @Override // com.mbridge.msdk.thrid.okio.ForwardingSink, com.mbridge.msdk.thrid.okio.Sink, java.io.Flushable
+    public void flush() throws IOException {
+        if (this.hasErrors) {
+            return;
+        }
+        try {
+            super.flush();
+        } catch (IOException e) {
+            this.hasErrors = true;
+            onException(e);
+        }
+    }
+
+    @Override // com.mbridge.msdk.thrid.okio.ForwardingSink, com.mbridge.msdk.thrid.okio.Sink, java.io.Closeable, java.lang.AutoCloseable
+    public void close() throws IOException {
+        if (this.hasErrors) {
+            return;
+        }
+        try {
+            super.close();
+        } catch (IOException e) {
+            this.hasErrors = true;
+            onException(e);
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/thrid/okhttp/internal/cache/InternalCache.java

@@ -0,0 +1,20 @@
+package com.mbridge.msdk.thrid.okhttp.internal.cache;
+
+import com.mbridge.msdk.thrid.okhttp.Request;
+import com.mbridge.msdk.thrid.okhttp.Response;
+import java.io.IOException;
+
+/* loaded from: classes4.dex */
+public interface InternalCache {
+    Response get(Request request) throws IOException;
+
+    CacheRequest put(Response response) throws IOException;
+
+    void remove(Request request) throws IOException;
+
+    void trackConditionalCacheHit();
+
+    void trackResponse(CacheStrategy cacheStrategy);
+
+    void update(Response response, Response response2);
+}

decompiled/sources/com/mbridge/msdk/thrid/okhttp/internal/cache2/FileOperator.java

@@ -0,0 +1,36 @@
+package com.mbridge.msdk.thrid.okhttp.internal.cache2;
+
+import com.mbridge.msdk.thrid.okio.Buffer;
+import java.io.IOException;
+import java.nio.channels.FileChannel;
+
+/* loaded from: classes4.dex */
+final class FileOperator {
+    private final FileChannel fileChannel;
+
+    public FileOperator(FileChannel fileChannel) {
+        this.fileChannel = fileChannel;
+    }
+
+    public void write(long j, Buffer buffer, long j2) throws IOException {
+        if (j2 < 0 || j2 > buffer.size()) {
+            throw new IndexOutOfBoundsException();
+        }
+        while (j2 > 0) {
+            long transferFrom = this.fileChannel.transferFrom(buffer, j, j2);
+            j += transferFrom;
+            j2 -= transferFrom;
+        }
+    }
+
+    public void read(long j, Buffer buffer, long j2) throws IOException {
+        if (j2 < 0) {
+            throw new IndexOutOfBoundsException();
+        }
+        while (j2 > 0) {
+            long transferTo = this.fileChannel.transferTo(j, j2, buffer);
+            j += transferTo;
+            j2 -= transferTo;
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/thrid/okhttp/internal/cache2/Relay.java

@@ -0,0 +1,238 @@
+package com.mbridge.msdk.thrid.okhttp.internal.cache2;
+
+import com.mbridge.msdk.thrid.okhttp.internal.Util;
+import com.mbridge.msdk.thrid.okio.Buffer;
+import com.mbridge.msdk.thrid.okio.ByteString;
+import com.mbridge.msdk.thrid.okio.Source;
+import com.mbridge.msdk.thrid.okio.Timeout;
+import csdk.gluads.Consts;
+import java.io.File;
+import java.io.IOException;
+import java.io.RandomAccessFile;
+
+/* loaded from: classes4.dex */
+final class Relay {
+    private static final long FILE_HEADER_SIZE = 32;
+    static final ByteString PREFIX_CLEAN = ByteString.encodeUtf8("OkHttp cache v1\n");
+    static final ByteString PREFIX_DIRTY = ByteString.encodeUtf8("OkHttp DIRTY :(\n");
+    private static final int SOURCE_FILE = 2;
+    private static final int SOURCE_UPSTREAM = 1;
+    final long bufferMaxSize;
+    boolean complete;
+    RandomAccessFile file;
+    private final ByteString metadata;
+    int sourceCount;
+    Source upstream;
+    long upstreamPos;
+    Thread upstreamReader;
+    final Buffer upstreamBuffer = new Buffer();
+    final Buffer buffer = new Buffer();
+
+    public boolean isClosed() {
+        return this.file == null;
+    }
+
+    public ByteString metadata() {
+        return this.metadata;
+    }
+
+    private Relay(RandomAccessFile randomAccessFile, Source source, long j, ByteString byteString, long j2) {
+        this.file = randomAccessFile;
+        this.upstream = source;
+        this.complete = source == null;
+        this.upstreamPos = j;
+        this.metadata = byteString;
+        this.bufferMaxSize = j2;
+    }
+
+    public static Relay edit(File file, Source source, ByteString byteString, long j) throws IOException {
+        RandomAccessFile randomAccessFile = new RandomAccessFile(file, "rw");
+        Relay relay = new Relay(randomAccessFile, source, 0L, byteString, j);
+        randomAccessFile.setLength(0L);
+        relay.writeHeader(PREFIX_DIRTY, -1L, -1L);
+        return relay;
+    }
+
+    public static Relay read(File file) throws IOException {
+        RandomAccessFile randomAccessFile = new RandomAccessFile(file, "rw");
+        FileOperator fileOperator = new FileOperator(randomAccessFile.getChannel());
+        Buffer buffer = new Buffer();
+        fileOperator.read(0L, buffer, 32L);
+        if (!buffer.readByteString(r2.size()).equals(PREFIX_CLEAN)) {
+            throw new IOException("unreadable cache file");
+        }
+        long readLong = buffer.readLong();
+        long readLong2 = buffer.readLong();
+        Buffer buffer2 = new Buffer();
+        fileOperator.read(readLong + 32, buffer2, readLong2);
+        return new Relay(randomAccessFile, null, readLong, buffer2.readByteString(), 0L);
+    }
+
+    private void writeHeader(ByteString byteString, long j, long j2) throws IOException {
+        Buffer buffer = new Buffer();
+        buffer.write(byteString);
+        buffer.writeLong(j);
+        buffer.writeLong(j2);
+        if (buffer.size() != 32) {
+            throw new IllegalArgumentException();
+        }
+        new FileOperator(this.file.getChannel()).write(0L, buffer, 32L);
+    }
+
+    private void writeMetadata(long j) throws IOException {
+        Buffer buffer = new Buffer();
+        buffer.write(this.metadata);
+        new FileOperator(this.file.getChannel()).write(32 + j, buffer, this.metadata.size());
+    }
+
+    public void commit(long j) throws IOException {
+        writeMetadata(j);
+        this.file.getChannel().force(false);
+        writeHeader(PREFIX_CLEAN, j, this.metadata.size());
+        this.file.getChannel().force(false);
+        synchronized (this) {
+            this.complete = true;
+        }
+        Util.closeQuietly(this.upstream);
+        this.upstream = null;
+    }
+
+    public Source newSource() {
+        synchronized (this) {
+            try {
+                if (this.file == null) {
+                    return null;
+                }
+                this.sourceCount++;
+                return new RelaySource();
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+    }
+
+    public class RelaySource implements Source {
+        private FileOperator fileOperator;
+        private long sourcePos;
+        private final Timeout timeout = new Timeout();
+
+        @Override // com.mbridge.msdk.thrid.okio.Source
+        public Timeout timeout() {
+            return this.timeout;
+        }
+
+        public RelaySource() {
+            this.fileOperator = new FileOperator(Relay.this.file.getChannel());
+        }
+
+        @Override // com.mbridge.msdk.thrid.okio.Source
+        public long read(Buffer buffer, long j) throws IOException {
+            Relay relay;
+            if (this.fileOperator == null) {
+                throw new IllegalStateException(Consts.PLACEMENT_STATUS_CLOSED);
+            }
+            synchronized (Relay.this) {
+                while (true) {
+                    try {
+                        long j2 = this.sourcePos;
+                        Relay relay2 = Relay.this;
+                        long j3 = relay2.upstreamPos;
+                        if (j2 != j3) {
+                            long size = j3 - relay2.buffer.size();
+                            long j4 = this.sourcePos;
+                            if (j4 < size) {
+                                long min = Math.min(j, j3 - j4);
+                                this.fileOperator.read(this.sourcePos + 32, buffer, min);
+                                this.sourcePos += min;
+                                return min;
+                            }
+                            long min2 = Math.min(j, j3 - j4);
+                            Relay.this.buffer.copyTo(buffer, this.sourcePos - size, min2);
+                            this.sourcePos += min2;
+                            return min2;
+                        }
+                        if (relay2.complete) {
+                            return -1L;
+                        }
+                        if (relay2.upstreamReader == null) {
+                            relay2.upstreamReader = Thread.currentThread();
+                            try {
+                                Relay relay3 = Relay.this;
+                                long read = relay3.upstream.read(relay3.upstreamBuffer, relay3.bufferMaxSize);
+                                if (read == -1) {
+                                    Relay.this.commit(j3);
+                                    synchronized (Relay.this) {
+                                        Relay relay4 = Relay.this;
+                                        relay4.upstreamReader = null;
+                                        relay4.notifyAll();
+                                    }
+                                    return -1L;
+                                }
+                                long min3 = Math.min(read, j);
+                                Relay.this.upstreamBuffer.copyTo(buffer, 0L, min3);
+                                this.sourcePos += min3;
+                                this.fileOperator.write(j3 + 32, Relay.this.upstreamBuffer.m3722clone(), read);
+                                synchronized (Relay.this) {
+                                    try {
+                                        Relay relay5 = Relay.this;
+                                        relay5.buffer.write(relay5.upstreamBuffer, read);
+                                        long size2 = Relay.this.buffer.size();
+                                        Relay relay6 = Relay.this;
+                                        if (size2 > relay6.bufferMaxSize) {
+                                            Buffer buffer2 = relay6.buffer;
+                                            buffer2.skip(buffer2.size() - Relay.this.bufferMaxSize);
+                                        }
+                                        relay = Relay.this;
+                                        relay.upstreamPos += read;
+                                    } finally {
+                                    }
+                                }
+                                synchronized (relay) {
+                                    Relay relay7 = Relay.this;
+                                    relay7.upstreamReader = null;
+                                    relay7.notifyAll();
+                                }
+                                return min3;
+                            } catch (Throwable th) {
+                                synchronized (Relay.this) {
+                                    Relay relay8 = Relay.this;
+                                    relay8.upstreamReader = null;
+                                    relay8.notifyAll();
+                                    throw th;
+                                }
+                            }
+                        }
+                        this.timeout.waitUntilNotified(relay2);
+                    } finally {
+                    }
+                }
+            }
+        }
+
+        @Override // com.mbridge.msdk.thrid.okio.Source, java.io.Closeable, java.lang.AutoCloseable
+        public void close() throws IOException {
+            if (this.fileOperator == null) {
+                return;
+            }
+            RandomAccessFile randomAccessFile = null;
+            this.fileOperator = null;
+            synchronized (Relay.this) {
+                try {
+                    Relay relay = Relay.this;
+                    int i = relay.sourceCount - 1;
+                    relay.sourceCount = i;
+                    if (i == 0) {
+                        RandomAccessFile randomAccessFile2 = relay.file;
+                        relay.file = null;
+                        randomAccessFile = randomAccessFile2;
+                    }
+                } catch (Throwable th) {
+                    throw th;
+                }
+            }
+            if (randomAccessFile != null) {
+                Util.closeQuietly(randomAccessFile);
+            }
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/thrid/okhttp/internal/connection/ConnectInterceptor.java

@@ -0,0 +1,25 @@
+package com.mbridge.msdk.thrid.okhttp.internal.connection;
+
+import com.mbridge.msdk.thrid.okhttp.Interceptor;
+import com.mbridge.msdk.thrid.okhttp.OkHttpClient;
+import com.mbridge.msdk.thrid.okhttp.Request;
+import com.mbridge.msdk.thrid.okhttp.Response;
+import com.mbridge.msdk.thrid.okhttp.internal.http.RealInterceptorChain;
+import java.io.IOException;
+
+/* loaded from: classes4.dex */
+public final class ConnectInterceptor implements Interceptor {
+    public final OkHttpClient client;
+
+    public ConnectInterceptor(OkHttpClient okHttpClient) {
+        this.client = okHttpClient;
+    }
+
+    @Override // com.mbridge.msdk.thrid.okhttp.Interceptor
+    public Response intercept(Interceptor.Chain chain) throws IOException {
+        RealInterceptorChain realInterceptorChain = (RealInterceptorChain) chain;
+        Request request = realInterceptorChain.request();
+        StreamAllocation streamAllocation = realInterceptorChain.streamAllocation();
+        return realInterceptorChain.proceed(request, streamAllocation, streamAllocation.newStream(this.client, chain, !request.method().equals("GET")), streamAllocation.connection());
+    }
+}

decompiled/sources/com/mbridge/msdk/thrid/okhttp/internal/connection/ConnectionSpecSelector.java

@@ -0,0 +1,73 @@
+package com.mbridge.msdk.thrid.okhttp.internal.connection;
+
+import com.mbridge.msdk.thrid.okhttp.ConnectionSpec;
+import com.mbridge.msdk.thrid.okhttp.internal.Internal;
+import java.io.IOException;
+import java.io.InterruptedIOException;
+import java.net.ProtocolException;
+import java.net.UnknownServiceException;
+import java.security.cert.CertificateException;
+import java.util.Arrays;
+import java.util.List;
+import javax.net.ssl.SSLException;
+import javax.net.ssl.SSLHandshakeException;
+import javax.net.ssl.SSLPeerUnverifiedException;
+import javax.net.ssl.SSLProtocolException;
+import javax.net.ssl.SSLSocket;
+
+/* loaded from: classes4.dex */
+public final class ConnectionSpecSelector {
+    private final List<ConnectionSpec> connectionSpecs;
+    private boolean isFallback;
+    private boolean isFallbackPossible;
+    private int nextModeIndex = 0;
+
+    public ConnectionSpecSelector(List<ConnectionSpec> list) {
+        this.connectionSpecs = list;
+    }
+
+    public ConnectionSpec configureSecureSocket(SSLSocket sSLSocket) throws IOException {
+        ConnectionSpec connectionSpec;
+        int i = this.nextModeIndex;
+        int size = this.connectionSpecs.size();
+        while (true) {
+            if (i >= size) {
+                connectionSpec = null;
+                break;
+            }
+            connectionSpec = this.connectionSpecs.get(i);
+            if (connectionSpec.isCompatible(sSLSocket)) {
+                this.nextModeIndex = i + 1;
+                break;
+            }
+            i++;
+        }
+        if (connectionSpec == null) {
+            throw new UnknownServiceException("Unable to find acceptable protocols. isFallback=" + this.isFallback + ", modes=" + this.connectionSpecs + ", supported protocols=" + Arrays.toString(sSLSocket.getEnabledProtocols()));
+        }
+        this.isFallbackPossible = isFallbackPossible(sSLSocket);
+        Internal.instance.apply(connectionSpec, sSLSocket, this.isFallback);
+        return connectionSpec;
+    }
+
+    public boolean connectionFailed(IOException iOException) {
+        this.isFallback = true;
+        if (!this.isFallbackPossible || (iOException instanceof ProtocolException) || (iOException instanceof InterruptedIOException)) {
+            return false;
+        }
+        boolean z = iOException instanceof SSLHandshakeException;
+        if ((z && (iOException.getCause() instanceof CertificateException)) || (iOException instanceof SSLPeerUnverifiedException)) {
+            return false;
+        }
+        return z || (iOException instanceof SSLProtocolException) || (iOException instanceof SSLException);
+    }
+
+    private boolean isFallbackPossible(SSLSocket sSLSocket) {
+        for (int i = this.nextModeIndex; i < this.connectionSpecs.size(); i++) {
+            if (this.connectionSpecs.get(i).isCompatible(sSLSocket)) {
+                return true;
+            }
+        }
+        return false;
+    }
+}

decompiled/sources/com/mbridge/msdk/thrid/okhttp/internal/connection/RealConnection.java

@@ -0,0 +1,411 @@
+package com.mbridge.msdk.thrid.okhttp.internal.connection;
+
+import com.facebook.internal.security.CertificateUtil;
+import com.mbridge.msdk.thrid.okhttp.Address;
+import com.mbridge.msdk.thrid.okhttp.Call;
+import com.mbridge.msdk.thrid.okhttp.CertificatePinner;
+import com.mbridge.msdk.thrid.okhttp.Connection;
+import com.mbridge.msdk.thrid.okhttp.ConnectionPool;
+import com.mbridge.msdk.thrid.okhttp.ConnectionSpec;
+import com.mbridge.msdk.thrid.okhttp.EventListener;
+import com.mbridge.msdk.thrid.okhttp.Handshake;
+import com.mbridge.msdk.thrid.okhttp.HttpUrl;
+import com.mbridge.msdk.thrid.okhttp.Interceptor;
+import com.mbridge.msdk.thrid.okhttp.OkHttpClient;
+import com.mbridge.msdk.thrid.okhttp.Protocol;
+import com.mbridge.msdk.thrid.okhttp.Request;
+import com.mbridge.msdk.thrid.okhttp.Response;
+import com.mbridge.msdk.thrid.okhttp.Route;
+import com.mbridge.msdk.thrid.okhttp.internal.Internal;
+import com.mbridge.msdk.thrid.okhttp.internal.Util;
+import com.mbridge.msdk.thrid.okhttp.internal.Version;
+import com.mbridge.msdk.thrid.okhttp.internal.http.HttpCodec;
+import com.mbridge.msdk.thrid.okhttp.internal.http.HttpHeaders;
+import com.mbridge.msdk.thrid.okhttp.internal.http1.Http1Codec;
+import com.mbridge.msdk.thrid.okhttp.internal.http2.ErrorCode;
+import com.mbridge.msdk.thrid.okhttp.internal.http2.Http2Codec;
+import com.mbridge.msdk.thrid.okhttp.internal.http2.Http2Connection;
+import com.mbridge.msdk.thrid.okhttp.internal.http2.Http2Stream;
+import com.mbridge.msdk.thrid.okhttp.internal.platform.Platform;
+import com.mbridge.msdk.thrid.okhttp.internal.tls.OkHostnameVerifier;
+import com.mbridge.msdk.thrid.okhttp.internal.ws.RealWebSocket;
+import com.mbridge.msdk.thrid.okio.BufferedSink;
+import com.mbridge.msdk.thrid.okio.BufferedSource;
+import com.mbridge.msdk.thrid.okio.Okio;
+import com.mbridge.msdk.thrid.okio.Source;
+import com.mbridge.msdk.thrid.okio.Timeout;
+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.net.SocketTimeoutException;
+import java.security.cert.Certificate;
+import java.security.cert.X509Certificate;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.TimeUnit;
+import javax.net.ssl.SSLPeerUnverifiedException;
+import javax.net.ssl.SSLSession;
+import javax.net.ssl.SSLSocket;
+import org.apache.http.auth.AUTH;
+import org.apache.http.protocol.HTTP;
+
+/* loaded from: classes4.dex */
+public final class RealConnection extends Http2Connection.Listener implements Connection {
+    private static final int MAX_TUNNEL_ATTEMPTS = 21;
+    private static final String NPE_THROW_WITH_NULL = "throw with null exception";
+    private final ConnectionPool connectionPool;
+    private Handshake handshake;
+    private Http2Connection http2Connection;
+    public boolean noNewStreams;
+    private Protocol protocol;
+    private Socket rawSocket;
+    private final Route route;
+    private BufferedSink sink;
+    private Socket socket;
+    private BufferedSource source;
+    public int successCount;
+    public int allocationLimit = 1;
+    public final List<Reference<StreamAllocation>> allocations = new ArrayList();
+    public long idleAtNanos = Long.MAX_VALUE;
+
+    @Override // com.mbridge.msdk.thrid.okhttp.Connection
+    public Handshake handshake() {
+        return this.handshake;
+    }
+
+    public boolean isMultiplexed() {
+        return this.http2Connection != null;
+    }
+
+    @Override // com.mbridge.msdk.thrid.okhttp.Connection
+    public Protocol protocol() {
+        return this.protocol;
+    }
+
+    @Override // com.mbridge.msdk.thrid.okhttp.Connection
+    public Route route() {
+        return this.route;
+    }
+
+    @Override // com.mbridge.msdk.thrid.okhttp.Connection
+    public Socket socket() {
+        return this.socket;
+    }
+
+    public RealConnection(ConnectionPool connectionPool, Route route) {
+        this.connectionPool = connectionPool;
+        this.route = route;
+    }
+
+    public static RealConnection testConnection(ConnectionPool connectionPool, Route route, Socket socket, long j) {
+        RealConnection realConnection = new RealConnection(connectionPool, route);
+        realConnection.socket = socket;
+        realConnection.idleAtNanos = j;
+        return realConnection;
+    }
+
+    /* JADX WARN: Removed duplicated region for block: B:32:0x00ed  */
+    /* JADX WARN: Removed duplicated region for block: B:43:0x00fd A[ORIG_RETURN, RETURN] */
+    /* JADX WARN: Removed duplicated region for block: B:47:0x0131  */
+    /* JADX WARN: Removed duplicated region for block: B:49:0x013c  */
+    /* JADX WARN: Removed duplicated region for block: B:54:0x0144 A[SYNTHETIC] */
+    /* JADX WARN: Removed duplicated region for block: B:56:0x0137  */
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    public void connect(int r17, int r18, int r19, int r20, boolean r21, com.mbridge.msdk.thrid.okhttp.Call r22, com.mbridge.msdk.thrid.okhttp.EventListener r23) {
+        /*
+            Method dump skipped, instructions count: 346
+            To view this dump add '--comments-level debug' option
+        */
+        throw new UnsupportedOperationException("Method not decompiled: com.mbridge.msdk.thrid.okhttp.internal.connection.RealConnection.connect(int, int, int, int, boolean, com.mbridge.msdk.thrid.okhttp.Call, com.mbridge.msdk.thrid.okhttp.EventListener):void");
+    }
+
+    private void connectTunnel(int i, int i2, int i3, Call call, EventListener eventListener) throws IOException {
+        Request createTunnelRequest = createTunnelRequest();
+        HttpUrl url = createTunnelRequest.url();
+        for (int i4 = 0; i4 < 21; i4++) {
+            connectSocket(i, i2, call, eventListener);
+            createTunnelRequest = createTunnel(i2, i3, createTunnelRequest, url);
+            if (createTunnelRequest == null) {
+                return;
+            }
+            Util.closeQuietly(this.rawSocket);
+            this.rawSocket = null;
+            this.sink = null;
+            this.source = null;
+            eventListener.connectEnd(call, this.route.socketAddress(), this.route.proxy(), null);
+        }
+    }
+
+    private void connectSocket(int i, int i2, Call call, EventListener eventListener) throws IOException {
+        Proxy proxy = this.route.proxy();
+        this.rawSocket = (proxy.type() == Proxy.Type.DIRECT || proxy.type() == Proxy.Type.HTTP) ? this.route.address().socketFactory().createSocket() : new Socket(proxy);
+        eventListener.connectStart(call, this.route.socketAddress(), proxy);
+        this.rawSocket.setSoTimeout(i2);
+        try {
+            Platform.get().connectSocket(this.rawSocket, this.route.socketAddress(), i);
+            try {
+                this.source = Okio.buffer(Okio.source(this.rawSocket));
+                this.sink = Okio.buffer(Okio.sink(this.rawSocket));
+            } catch (NullPointerException e) {
+                if (NPE_THROW_WITH_NULL.equals(e.getMessage())) {
+                    throw new IOException(e);
+                }
+            }
+        } catch (ConnectException e2) {
+            ConnectException connectException = new ConnectException("Failed to connect to " + this.route.socketAddress());
+            connectException.initCause(e2);
+            throw connectException;
+        }
+    }
+
+    private void establishProtocol(ConnectionSpecSelector connectionSpecSelector, int i, Call call, EventListener eventListener) throws IOException {
+        if (this.route.address().sslSocketFactory() == null) {
+            List<Protocol> protocols = this.route.address().protocols();
+            Protocol protocol = Protocol.H2_PRIOR_KNOWLEDGE;
+            if (protocols.contains(protocol)) {
+                this.socket = this.rawSocket;
+                this.protocol = protocol;
+                startHttp2(i);
+                return;
+            } else {
+                this.socket = this.rawSocket;
+                this.protocol = Protocol.HTTP_1_1;
+                return;
+            }
+        }
+        eventListener.secureConnectStart(call);
+        connectTls(connectionSpecSelector);
+        eventListener.secureConnectEnd(call, this.handshake);
+        if (this.protocol == Protocol.HTTP_2) {
+            startHttp2(i);
+        }
+    }
+
+    private void startHttp2(int i) throws IOException {
+        this.socket.setSoTimeout(0);
+        Http2Connection build = new Http2Connection.Builder(true).socket(this.socket, this.route.address().url().host(), this.source, this.sink).listener(this).pingIntervalMillis(i).build();
+        this.http2Connection = build;
+        build.start();
+    }
+
+    private void connectTls(ConnectionSpecSelector connectionSpecSelector) throws IOException {
+        SSLSocket sSLSocket;
+        Address address = this.route.address();
+        SSLSocket sSLSocket2 = null;
+        try {
+            try {
+                sSLSocket = (SSLSocket) address.sslSocketFactory().createSocket(this.rawSocket, address.url().host(), address.url().port(), true);
+            } catch (AssertionError e) {
+                e = e;
+            }
+        } catch (Throwable th) {
+            th = th;
+        }
+        try {
+            ConnectionSpec configureSecureSocket = connectionSpecSelector.configureSecureSocket(sSLSocket);
+            if (configureSecureSocket.supportsTlsExtensions()) {
+                Platform.get().configureTlsExtensions(sSLSocket, address.url().host(), address.protocols());
+            }
+            sSLSocket.startHandshake();
+            SSLSession session = sSLSocket.getSession();
+            Handshake handshake = Handshake.get(session);
+            if (!address.hostnameVerifier().verify(address.url().host(), session)) {
+                List<Certificate> peerCertificates = handshake.peerCertificates();
+                if (!peerCertificates.isEmpty()) {
+                    X509Certificate x509Certificate = (X509Certificate) peerCertificates.get(0);
+                    throw new SSLPeerUnverifiedException("Hostname " + address.url().host() + " not verified:\n    certificate: " + CertificatePinner.pin(x509Certificate) + "\n    DN: " + x509Certificate.getSubjectDN().getName() + "\n    subjectAltNames: " + OkHostnameVerifier.allSubjectAltNames(x509Certificate));
+                }
+                throw new SSLPeerUnverifiedException("Hostname " + address.url().host() + " not verified (no certificates)");
+            }
+            address.certificatePinner().check(address.url().host(), handshake.peerCertificates());
+            String selectedProtocol = configureSecureSocket.supportsTlsExtensions() ? Platform.get().getSelectedProtocol(sSLSocket) : null;
+            this.socket = sSLSocket;
+            this.source = Okio.buffer(Okio.source(sSLSocket));
+            this.sink = Okio.buffer(Okio.sink(this.socket));
+            this.handshake = handshake;
+            this.protocol = selectedProtocol != null ? Protocol.get(selectedProtocol) : Protocol.HTTP_1_1;
+            Platform.get().afterHandshake(sSLSocket);
+        } catch (AssertionError e2) {
+            e = e2;
+            if (!Util.isAndroidGetsocknameError(e)) {
+                throw e;
+            }
+            throw new IOException(e);
+        } catch (Throwable th2) {
+            th = th2;
+            sSLSocket2 = sSLSocket;
+            if (sSLSocket2 != null) {
+                Platform.get().afterHandshake(sSLSocket2);
+            }
+            Util.closeQuietly((Socket) sSLSocket2);
+            throw th;
+        }
+    }
+
+    private Request createTunnel(int i, int i2, Request request, HttpUrl httpUrl) throws IOException {
+        String str = "CONNECT " + Util.hostHeader(httpUrl, true) + " HTTP/1.1";
+        while (true) {
+            Http1Codec http1Codec = new Http1Codec(null, null, this.source, this.sink);
+            TimeUnit timeUnit = TimeUnit.MILLISECONDS;
+            this.source.timeout().timeout(i, timeUnit);
+            this.sink.timeout().timeout(i2, timeUnit);
+            http1Codec.writeRequest(request.headers(), str);
+            http1Codec.finishRequest();
+            Response build = http1Codec.readResponseHeaders(false).request(request).build();
+            long contentLength = HttpHeaders.contentLength(build);
+            if (contentLength == -1) {
+                contentLength = 0;
+            }
+            Source newFixedLengthSource = http1Codec.newFixedLengthSource(contentLength);
+            Util.skipAll(newFixedLengthSource, Integer.MAX_VALUE, timeUnit);
+            newFixedLengthSource.close();
+            int code = build.code();
+            if (code == 200) {
+                if (this.source.buffer().exhausted() && this.sink.buffer().exhausted()) {
+                    return null;
+                }
+                throw new IOException("TLS tunnel buffered too many bytes!");
+            }
+            if (code == 407) {
+                Request authenticate = this.route.address().proxyAuthenticator().authenticate(this.route, build);
+                if (authenticate == null) {
+                    throw new IOException("Failed to authenticate with proxy");
+                }
+                if ("close".equalsIgnoreCase(build.header(HTTP.CONN_DIRECTIVE))) {
+                    return authenticate;
+                }
+                request = authenticate;
+            } else {
+                throw new IOException("Unexpected response code for CONNECT: " + build.code());
+            }
+        }
+    }
+
+    private Request createTunnelRequest() throws IOException {
+        Request build = new Request.Builder().url(this.route.address().url()).method("CONNECT", null).header(HTTP.TARGET_HOST, Util.hostHeader(this.route.address().url(), true)).header("Proxy-Connection", HTTP.CONN_KEEP_ALIVE).header("User-Agent", Version.userAgent()).build();
+        Request authenticate = this.route.address().proxyAuthenticator().authenticate(this.route, new Response.Builder().request(build).protocol(Protocol.HTTP_1_1).code(407).message("Preemptive Authenticate").body(Util.EMPTY_RESPONSE).sentRequestAtMillis(-1L).receivedResponseAtMillis(-1L).header(AUTH.PROXY_AUTH, "OkHttp-Preemptive").build());
+        return authenticate != null ? authenticate : build;
+    }
+
+    public boolean isEligible(Address address, Route route) {
+        if (this.allocations.size() >= this.allocationLimit || this.noNewStreams || !Internal.instance.equalsNonHost(this.route.address(), address)) {
+            return false;
+        }
+        if (address.url().host().equals(route().address().url().host())) {
+            return true;
+        }
+        if (this.http2Connection == null || route == null) {
+            return false;
+        }
+        Proxy.Type type = route.proxy().type();
+        Proxy.Type type2 = Proxy.Type.DIRECT;
+        if (type != type2 || this.route.proxy().type() != type2 || !this.route.socketAddress().equals(route.socketAddress()) || route.address().hostnameVerifier() != OkHostnameVerifier.INSTANCE || !supportsUrl(address.url())) {
+            return false;
+        }
+        try {
+            address.certificatePinner().check(address.url().host(), handshake().peerCertificates());
+            return true;
+        } catch (SSLPeerUnverifiedException unused) {
+            return false;
+        }
+    }
+
+    public boolean supportsUrl(HttpUrl httpUrl) {
+        if (httpUrl.port() != this.route.address().url().port()) {
+            return false;
+        }
+        if (httpUrl.host().equals(this.route.address().url().host())) {
+            return true;
+        }
+        return this.handshake != null && OkHostnameVerifier.INSTANCE.verify(httpUrl.host(), (X509Certificate) this.handshake.peerCertificates().get(0));
+    }
+
+    public HttpCodec newCodec(OkHttpClient okHttpClient, Interceptor.Chain chain, StreamAllocation streamAllocation) throws SocketException {
+        if (this.http2Connection != null) {
+            return new Http2Codec(okHttpClient, chain, streamAllocation, this.http2Connection);
+        }
+        this.socket.setSoTimeout(chain.readTimeoutMillis());
+        Timeout timeout = this.source.timeout();
+        long readTimeoutMillis = chain.readTimeoutMillis();
+        TimeUnit timeUnit = TimeUnit.MILLISECONDS;
+        timeout.timeout(readTimeoutMillis, timeUnit);
+        this.sink.timeout().timeout(chain.writeTimeoutMillis(), timeUnit);
+        return new Http1Codec(okHttpClient, streamAllocation, this.source, this.sink);
+    }
+
+    public RealWebSocket.Streams newWebSocketStreams(final StreamAllocation streamAllocation) {
+        return new RealWebSocket.Streams(true, this.source, this.sink) { // from class: com.mbridge.msdk.thrid.okhttp.internal.connection.RealConnection.1
+            @Override // java.io.Closeable, java.lang.AutoCloseable
+            public void close() throws IOException {
+                StreamAllocation streamAllocation2 = streamAllocation;
+                streamAllocation2.streamFinished(true, streamAllocation2.codec(), -1L, null);
+            }
+        };
+    }
+
+    public void cancel() {
+        Util.closeQuietly(this.rawSocket);
+    }
+
+    public boolean isHealthy(boolean z) {
+        if (this.socket.isClosed() || this.socket.isInputShutdown() || this.socket.isOutputShutdown()) {
+            return false;
+        }
+        Http2Connection http2Connection = this.http2Connection;
+        if (http2Connection != null) {
+            return http2Connection.isHealthy(System.nanoTime());
+        }
+        if (z) {
+            try {
+                int soTimeout = this.socket.getSoTimeout();
+                try {
+                    this.socket.setSoTimeout(1);
+                    return !this.source.exhausted();
+                } finally {
+                    this.socket.setSoTimeout(soTimeout);
+                }
+            } catch (SocketTimeoutException unused) {
+            } catch (IOException unused2) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    @Override // com.mbridge.msdk.thrid.okhttp.internal.http2.Http2Connection.Listener
+    public void onStream(Http2Stream http2Stream) throws IOException {
+        http2Stream.close(ErrorCode.REFUSED_STREAM);
+    }
+
+    @Override // com.mbridge.msdk.thrid.okhttp.internal.http2.Http2Connection.Listener
+    public void onSettings(Http2Connection http2Connection) {
+        synchronized (this.connectionPool) {
+            this.allocationLimit = http2Connection.maxConcurrentStreams();
+        }
+    }
+
+    public String toString() {
+        StringBuilder sb = new StringBuilder();
+        sb.append("Connection{");
+        sb.append(this.route.address().url().host());
+        sb.append(CertificateUtil.DELIMITER);
+        sb.append(this.route.address().url().port());
+        sb.append(", proxy=");
+        sb.append(this.route.proxy());
+        sb.append(" hostAddress=");
+        sb.append(this.route.socketAddress());
+        sb.append(" cipherSuite=");
+        Handshake handshake = this.handshake;
+        sb.append(handshake != null ? handshake.cipherSuite() : "none");
+        sb.append(" protocol=");
+        sb.append(this.protocol);
+        sb.append('}');
+        return sb.toString();
+    }
+}

decompiled/sources/com/mbridge/msdk/thrid/okhttp/internal/connection/RouteDatabase.java

@@ -0,0 +1,22 @@
+package com.mbridge.msdk.thrid.okhttp.internal.connection;
+
+import com.mbridge.msdk.thrid.okhttp.Route;
+import java.util.LinkedHashSet;
+import java.util.Set;
+
+/* loaded from: classes4.dex */
+public final class RouteDatabase {
+    private final Set<Route> failedRoutes = new LinkedHashSet();
+
+    public synchronized void failed(Route route) {
+        this.failedRoutes.add(route);
+    }
+
+    public synchronized void connected(Route route) {
+        this.failedRoutes.remove(route);
+    }
+
+    public synchronized boolean shouldPostpone(Route route) {
+        return this.failedRoutes.contains(route);
+    }
+}

decompiled/sources/com/mbridge/msdk/thrid/okhttp/internal/connection/RouteException.java

@@ -0,0 +1,29 @@
+package com.mbridge.msdk.thrid.okhttp.internal.connection;
+
+import com.mbridge.msdk.thrid.okhttp.internal.Util;
+import java.io.IOException;
+
+/* loaded from: classes4.dex */
+public final class RouteException extends RuntimeException {
+    private IOException firstException;
+    private IOException lastException;
+
+    public IOException getFirstConnectException() {
+        return this.firstException;
+    }
+
+    public IOException getLastConnectException() {
+        return this.lastException;
+    }
+
+    public RouteException(IOException iOException) {
+        super(iOException);
+        this.firstException = iOException;
+        this.lastException = iOException;
+    }
+
+    public void addConnectException(IOException iOException) {
+        Util.addSuppressedIfPossible(this.firstException, iOException);
+        this.lastException = iOException;
+    }
+}

decompiled/sources/com/mbridge/msdk/thrid/okhttp/internal/connection/RouteSelector.java

@@ -0,0 +1,180 @@
+package com.mbridge.msdk.thrid.okhttp.internal.connection;
+
+import com.facebook.internal.security.CertificateUtil;
+import com.mbridge.msdk.thrid.okhttp.Address;
+import com.mbridge.msdk.thrid.okhttp.Call;
+import com.mbridge.msdk.thrid.okhttp.EventListener;
+import com.mbridge.msdk.thrid.okhttp.HttpUrl;
+import com.mbridge.msdk.thrid.okhttp.Route;
+import com.mbridge.msdk.thrid.okhttp.internal.Util;
+import java.io.IOException;
+import java.net.InetAddress;
+import java.net.InetSocketAddress;
+import java.net.Proxy;
+import java.net.SocketAddress;
+import java.net.SocketException;
+import java.net.UnknownHostException;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.NoSuchElementException;
+
+/* loaded from: classes4.dex */
+public final class RouteSelector {
+    private final Address address;
+    private final Call call;
+    private final EventListener eventListener;
+    private int nextProxyIndex;
+    private final RouteDatabase routeDatabase;
+    private List<Proxy> proxies = Collections.emptyList();
+    private List<InetSocketAddress> inetSocketAddresses = Collections.emptyList();
+    private final List<Route> postponedRoutes = new ArrayList();
+
+    public RouteSelector(Address address, RouteDatabase routeDatabase, Call call, EventListener eventListener) {
+        this.address = address;
+        this.routeDatabase = routeDatabase;
+        this.call = call;
+        this.eventListener = eventListener;
+        resetNextProxy(address.url(), address.proxy());
+    }
+
+    public boolean hasNext() {
+        return hasNextProxy() || !this.postponedRoutes.isEmpty();
+    }
+
+    public Selection next() throws IOException {
+        if (!hasNext()) {
+            throw new NoSuchElementException();
+        }
+        ArrayList arrayList = new ArrayList();
+        while (hasNextProxy()) {
+            Proxy nextProxy = nextProxy();
+            int size = this.inetSocketAddresses.size();
+            for (int i = 0; i < size; i++) {
+                Route route = new Route(this.address, nextProxy, this.inetSocketAddresses.get(i));
+                if (this.routeDatabase.shouldPostpone(route)) {
+                    this.postponedRoutes.add(route);
+                } else {
+                    arrayList.add(route);
+                }
+            }
+            if (!arrayList.isEmpty()) {
+                break;
+            }
+        }
+        if (arrayList.isEmpty()) {
+            arrayList.addAll(this.postponedRoutes);
+            this.postponedRoutes.clear();
+        }
+        return new Selection(arrayList);
+    }
+
+    public void connectFailed(Route route, IOException iOException) {
+        if (route.proxy().type() != Proxy.Type.DIRECT && this.address.proxySelector() != null) {
+            this.address.proxySelector().connectFailed(this.address.url().uri(), route.proxy().address(), iOException);
+        }
+        this.routeDatabase.failed(route);
+    }
+
+    private void resetNextProxy(HttpUrl httpUrl, Proxy proxy) {
+        List<Proxy> immutableList;
+        if (proxy != null) {
+            this.proxies = Collections.singletonList(proxy);
+        } else {
+            List<Proxy> select = this.address.proxySelector().select(httpUrl.uri());
+            if (select != null && !select.isEmpty()) {
+                immutableList = Util.immutableList(select);
+            } else {
+                immutableList = Util.immutableList(Proxy.NO_PROXY);
+            }
+            this.proxies = immutableList;
+        }
+        this.nextProxyIndex = 0;
+    }
+
+    private boolean hasNextProxy() {
+        return this.nextProxyIndex < this.proxies.size();
+    }
+
+    private Proxy nextProxy() throws IOException {
+        if (!hasNextProxy()) {
+            throw new SocketException("No route to " + this.address.url().host() + "; exhausted proxy configurations: " + this.proxies);
+        }
+        List<Proxy> list = this.proxies;
+        int i = this.nextProxyIndex;
+        this.nextProxyIndex = i + 1;
+        Proxy proxy = list.get(i);
+        resetNextInetSocketAddress(proxy);
+        return proxy;
+    }
+
+    private void resetNextInetSocketAddress(Proxy proxy) throws IOException {
+        String host;
+        int port;
+        this.inetSocketAddresses = new ArrayList();
+        if (proxy.type() == Proxy.Type.DIRECT || proxy.type() == Proxy.Type.SOCKS) {
+            host = this.address.url().host();
+            port = this.address.url().port();
+        } else {
+            SocketAddress address = proxy.address();
+            if (!(address instanceof InetSocketAddress)) {
+                throw new IllegalArgumentException("Proxy.address() is not an InetSocketAddress: " + address.getClass());
+            }
+            InetSocketAddress inetSocketAddress = (InetSocketAddress) address;
+            host = getHostString(inetSocketAddress);
+            port = inetSocketAddress.getPort();
+        }
+        if (port < 1 || port > 65535) {
+            throw new SocketException("No route to " + host + CertificateUtil.DELIMITER + port + "; port is out of range");
+        }
+        if (proxy.type() == Proxy.Type.SOCKS) {
+            this.inetSocketAddresses.add(InetSocketAddress.createUnresolved(host, port));
+            return;
+        }
+        this.eventListener.dnsStart(this.call, host);
+        List<InetAddress> lookup = this.address.dns().lookup(host);
+        if (lookup.isEmpty()) {
+            throw new UnknownHostException(this.address.dns() + " returned no addresses for " + host);
+        }
+        this.eventListener.dnsEnd(this.call, host, lookup);
+        int size = lookup.size();
+        for (int i = 0; i < size; i++) {
+            this.inetSocketAddresses.add(new InetSocketAddress(lookup.get(i), port));
+        }
+    }
+
+    public static String getHostString(InetSocketAddress inetSocketAddress) {
+        InetAddress address = inetSocketAddress.getAddress();
+        if (address == null) {
+            return inetSocketAddress.getHostName();
+        }
+        return address.getHostAddress();
+    }
+
+    public static final class Selection {
+        private int nextRouteIndex = 0;
+        private final List<Route> routes;
+
+        public Selection(List<Route> list) {
+            this.routes = list;
+        }
+
+        public boolean hasNext() {
+            return this.nextRouteIndex < this.routes.size();
+        }
+
+        public Route next() {
+            if (!hasNext()) {
+                throw new NoSuchElementException();
+            }
+            List<Route> list = this.routes;
+            int i = this.nextRouteIndex;
+            this.nextRouteIndex = i + 1;
+            return list.get(i);
+        }
+
+        public List<Route> getAll() {
+            return new ArrayList(this.routes);
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/thrid/okhttp/internal/connection/StreamAllocation.java

@@ -0,0 +1,457 @@
+package com.mbridge.msdk.thrid.okhttp.internal.connection;
+
+import com.mbridge.msdk.thrid.okhttp.Address;
+import com.mbridge.msdk.thrid.okhttp.Call;
+import com.mbridge.msdk.thrid.okhttp.ConnectionPool;
+import com.mbridge.msdk.thrid.okhttp.EventListener;
+import com.mbridge.msdk.thrid.okhttp.Interceptor;
+import com.mbridge.msdk.thrid.okhttp.OkHttpClient;
+import com.mbridge.msdk.thrid.okhttp.Route;
+import com.mbridge.msdk.thrid.okhttp.internal.Internal;
+import com.mbridge.msdk.thrid.okhttp.internal.Util;
+import com.mbridge.msdk.thrid.okhttp.internal.connection.RouteSelector;
+import com.mbridge.msdk.thrid.okhttp.internal.http.HttpCodec;
+import com.mbridge.msdk.thrid.okhttp.internal.http2.ConnectionShutdownException;
+import com.mbridge.msdk.thrid.okhttp.internal.http2.ErrorCode;
+import com.mbridge.msdk.thrid.okhttp.internal.http2.StreamResetException;
+import java.io.IOException;
+import java.lang.ref.Reference;
+import java.lang.ref.WeakReference;
+import java.net.Socket;
+import java.util.List;
+
+/* loaded from: classes4.dex */
+public final class StreamAllocation {
+    static final /* synthetic */ boolean $assertionsDisabled = false;
+    public final Address address;
+    public final Call call;
+    private final Object callStackTrace;
+    private boolean canceled;
+    private HttpCodec codec;
+    private RealConnection connection;
+    private final ConnectionPool connectionPool;
+    public final EventListener eventListener;
+    private int refusedStreamCount;
+    private boolean released;
+    private boolean reportedAcquired;
+    private Route route;
+    private RouteSelector.Selection routeSelection;
+    private final RouteSelector routeSelector;
+
+    public Route route() {
+        return this.route;
+    }
+
+    public StreamAllocation(ConnectionPool connectionPool, Address address, Call call, EventListener eventListener, Object obj) {
+        this.connectionPool = connectionPool;
+        this.address = address;
+        this.call = call;
+        this.eventListener = eventListener;
+        this.routeSelector = new RouteSelector(address, routeDatabase(), call, eventListener);
+        this.callStackTrace = obj;
+    }
+
+    public HttpCodec newStream(OkHttpClient okHttpClient, Interceptor.Chain chain, boolean z) {
+        try {
+            HttpCodec newCodec = findHealthyConnection(chain.connectTimeoutMillis(), chain.readTimeoutMillis(), chain.writeTimeoutMillis(), okHttpClient.pingIntervalMillis(), okHttpClient.retryOnConnectionFailure(), z).newCodec(okHttpClient, chain, this);
+            synchronized (this.connectionPool) {
+                this.codec = newCodec;
+            }
+            return newCodec;
+        } catch (IOException e) {
+            throw new RouteException(e);
+        }
+    }
+
+    private RealConnection findHealthyConnection(int i, int i2, int i3, int i4, boolean z, boolean z2) throws IOException {
+        while (true) {
+            RealConnection findConnection = findConnection(i, i2, i3, i4, z);
+            synchronized (this.connectionPool) {
+                try {
+                    if (findConnection.successCount == 0 && !findConnection.isMultiplexed()) {
+                        return findConnection;
+                    }
+                    if (findConnection.isHealthy(z2)) {
+                        return findConnection;
+                    }
+                    noNewStreams();
+                } catch (Throwable th) {
+                    throw th;
+                }
+            }
+        }
+    }
+
+    private RealConnection findConnection(int i, int i2, int i3, int i4, boolean z) throws IOException {
+        RealConnection realConnection;
+        Socket releaseIfNoNewStreams;
+        RealConnection realConnection2;
+        Socket socket;
+        Route route;
+        boolean z2;
+        boolean z3;
+        RouteSelector.Selection selection;
+        synchronized (this.connectionPool) {
+            try {
+                if (this.released) {
+                    throw new IllegalStateException("released");
+                }
+                if (this.codec != null) {
+                    throw new IllegalStateException("codec != null");
+                }
+                if (this.canceled) {
+                    throw new IOException("Canceled");
+                }
+                realConnection = this.connection;
+                releaseIfNoNewStreams = releaseIfNoNewStreams();
+                realConnection2 = this.connection;
+                socket = null;
+                if (realConnection2 != null) {
+                    realConnection = null;
+                } else {
+                    realConnection2 = null;
+                }
+                if (!this.reportedAcquired) {
+                    realConnection = null;
+                }
+                if (realConnection2 == null) {
+                    Internal.instance.get(this.connectionPool, this.address, this, null);
+                    RealConnection realConnection3 = this.connection;
+                    if (realConnection3 != null) {
+                        z2 = true;
+                        realConnection2 = realConnection3;
+                        route = null;
+                    } else {
+                        route = this.route;
+                    }
+                } else {
+                    route = null;
+                }
+                z2 = false;
+            } finally {
+            }
+        }
+        Util.closeQuietly(releaseIfNoNewStreams);
+        if (realConnection != null) {
+            this.eventListener.connectionReleased(this.call, realConnection);
+        }
+        if (z2) {
+            this.eventListener.connectionAcquired(this.call, realConnection2);
+        }
+        if (realConnection2 != null) {
+            this.route = this.connection.route();
+            return realConnection2;
+        }
+        if (route != null || ((selection = this.routeSelection) != null && selection.hasNext())) {
+            z3 = false;
+        } else {
+            this.routeSelection = this.routeSelector.next();
+            z3 = true;
+        }
+        synchronized (this.connectionPool) {
+            try {
+                if (this.canceled) {
+                    throw new IOException("Canceled");
+                }
+                if (z3) {
+                    List<Route> all = this.routeSelection.getAll();
+                    int size = all.size();
+                    int i5 = 0;
+                    while (true) {
+                        if (i5 >= size) {
+                            break;
+                        }
+                        Route route2 = all.get(i5);
+                        Internal.instance.get(this.connectionPool, this.address, this, route2);
+                        RealConnection realConnection4 = this.connection;
+                        if (realConnection4 != null) {
+                            this.route = route2;
+                            z2 = true;
+                            realConnection2 = realConnection4;
+                            break;
+                        }
+                        i5++;
+                    }
+                }
+                if (!z2) {
+                    if (route == null) {
+                        route = this.routeSelection.next();
+                    }
+                    this.route = route;
+                    this.refusedStreamCount = 0;
+                    realConnection2 = new RealConnection(this.connectionPool, route);
+                    acquire(realConnection2, false);
+                }
+            } finally {
+            }
+        }
+        if (z2) {
+            this.eventListener.connectionAcquired(this.call, realConnection2);
+            return realConnection2;
+        }
+        realConnection2.connect(i, i2, i3, i4, z, this.call, this.eventListener);
+        routeDatabase().connected(realConnection2.route());
+        synchronized (this.connectionPool) {
+            try {
+                this.reportedAcquired = true;
+                Internal.instance.put(this.connectionPool, realConnection2);
+                if (realConnection2.isMultiplexed()) {
+                    socket = Internal.instance.deduplicate(this.connectionPool, this.address, this);
+                    realConnection2 = this.connection;
+                }
+            } finally {
+            }
+        }
+        Util.closeQuietly(socket);
+        this.eventListener.connectionAcquired(this.call, realConnection2);
+        return realConnection2;
+    }
+
+    private Socket releaseIfNoNewStreams() {
+        RealConnection realConnection = this.connection;
+        if (realConnection == null || !realConnection.noNewStreams) {
+            return null;
+        }
+        return deallocate(false, false, true);
+    }
+
+    public void streamFinished(boolean z, HttpCodec httpCodec, long j, IOException iOException) {
+        RealConnection realConnection;
+        Socket deallocate;
+        boolean z2;
+        this.eventListener.responseBodyEnd(this.call, j);
+        synchronized (this.connectionPool) {
+            if (httpCodec != null) {
+                try {
+                    if (httpCodec == this.codec) {
+                        if (!z) {
+                            this.connection.successCount++;
+                        }
+                        realConnection = this.connection;
+                        deallocate = deallocate(z, false, true);
+                        if (this.connection != null) {
+                            realConnection = null;
+                        }
+                        z2 = this.released;
+                    }
+                } catch (Throwable th) {
+                    throw th;
+                }
+            }
+            throw new IllegalStateException("expected " + this.codec + " but was " + httpCodec);
+        }
+        Util.closeQuietly(deallocate);
+        if (realConnection != null) {
+            this.eventListener.connectionReleased(this.call, realConnection);
+        }
+        if (iOException != null) {
+            this.eventListener.callFailed(this.call, Internal.instance.timeoutExit(this.call, iOException));
+        } else if (z2) {
+            Internal.instance.timeoutExit(this.call, null);
+            this.eventListener.callEnd(this.call);
+        }
+    }
+
+    public HttpCodec codec() {
+        HttpCodec httpCodec;
+        synchronized (this.connectionPool) {
+            httpCodec = this.codec;
+        }
+        return httpCodec;
+    }
+
+    private RouteDatabase routeDatabase() {
+        return Internal.instance.routeDatabase(this.connectionPool);
+    }
+
+    public synchronized RealConnection connection() {
+        return this.connection;
+    }
+
+    public void release() {
+        RealConnection realConnection;
+        Socket deallocate;
+        synchronized (this.connectionPool) {
+            realConnection = this.connection;
+            deallocate = deallocate(false, true, false);
+            if (this.connection != null) {
+                realConnection = null;
+            }
+        }
+        Util.closeQuietly(deallocate);
+        if (realConnection != null) {
+            Internal.instance.timeoutExit(this.call, null);
+            this.eventListener.connectionReleased(this.call, realConnection);
+            this.eventListener.callEnd(this.call);
+        }
+    }
+
+    public void noNewStreams() {
+        RealConnection realConnection;
+        Socket deallocate;
+        synchronized (this.connectionPool) {
+            realConnection = this.connection;
+            deallocate = deallocate(true, false, false);
+            if (this.connection != null) {
+                realConnection = null;
+            }
+        }
+        Util.closeQuietly(deallocate);
+        if (realConnection != null) {
+            this.eventListener.connectionReleased(this.call, realConnection);
+        }
+    }
+
+    private Socket deallocate(boolean z, boolean z2, boolean z3) {
+        Socket socket;
+        if (z3) {
+            this.codec = null;
+        }
+        if (z2) {
+            this.released = true;
+        }
+        RealConnection realConnection = this.connection;
+        if (realConnection == null) {
+            return null;
+        }
+        if (z) {
+            realConnection.noNewStreams = true;
+        }
+        if (this.codec != null) {
+            return null;
+        }
+        if (!this.released && !realConnection.noNewStreams) {
+            return null;
+        }
+        release(realConnection);
+        if (this.connection.allocations.isEmpty()) {
+            this.connection.idleAtNanos = System.nanoTime();
+            if (Internal.instance.connectionBecameIdle(this.connectionPool, this.connection)) {
+                socket = this.connection.socket();
+                this.connection = null;
+                return socket;
+            }
+        }
+        socket = null;
+        this.connection = null;
+        return socket;
+    }
+
+    public void cancel() {
+        HttpCodec httpCodec;
+        RealConnection realConnection;
+        synchronized (this.connectionPool) {
+            this.canceled = true;
+            httpCodec = this.codec;
+            realConnection = this.connection;
+        }
+        if (httpCodec != null) {
+            httpCodec.cancel();
+        } else if (realConnection != null) {
+            realConnection.cancel();
+        }
+    }
+
+    public void streamFailed(IOException iOException) {
+        RealConnection realConnection;
+        boolean z;
+        Socket deallocate;
+        synchronized (this.connectionPool) {
+            try {
+                realConnection = null;
+                if (iOException instanceof StreamResetException) {
+                    ErrorCode errorCode = ((StreamResetException) iOException).errorCode;
+                    if (errorCode == ErrorCode.REFUSED_STREAM) {
+                        int i = this.refusedStreamCount + 1;
+                        this.refusedStreamCount = i;
+                        if (i > 1) {
+                            this.route = null;
+                            z = true;
+                        }
+                        z = false;
+                    } else {
+                        if (errorCode != ErrorCode.CANCEL) {
+                            this.route = null;
+                            z = true;
+                        }
+                        z = false;
+                    }
+                } else {
+                    RealConnection realConnection2 = this.connection;
+                    if (realConnection2 != null && (!realConnection2.isMultiplexed() || (iOException instanceof ConnectionShutdownException))) {
+                        if (this.connection.successCount == 0) {
+                            Route route = this.route;
+                            if (route != null && iOException != null) {
+                                this.routeSelector.connectFailed(route, iOException);
+                            }
+                            this.route = null;
+                        }
+                        z = true;
+                    }
+                    z = false;
+                }
+                RealConnection realConnection3 = this.connection;
+                deallocate = deallocate(z, false, true);
+                if (this.connection == null && this.reportedAcquired) {
+                    realConnection = realConnection3;
+                }
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+        Util.closeQuietly(deallocate);
+        if (realConnection != null) {
+            this.eventListener.connectionReleased(this.call, realConnection);
+        }
+    }
+
+    public void acquire(RealConnection realConnection, boolean z) {
+        if (this.connection != null) {
+            throw new IllegalStateException();
+        }
+        this.connection = realConnection;
+        this.reportedAcquired = z;
+        realConnection.allocations.add(new StreamAllocationReference(this, this.callStackTrace));
+    }
+
+    private void release(RealConnection realConnection) {
+        int size = realConnection.allocations.size();
+        for (int i = 0; i < size; i++) {
+            if (realConnection.allocations.get(i).get() == this) {
+                realConnection.allocations.remove(i);
+                return;
+            }
+        }
+        throw new IllegalStateException();
+    }
+
+    public Socket releaseAndAcquire(RealConnection realConnection) {
+        if (this.codec != null || this.connection.allocations.size() != 1) {
+            throw new IllegalStateException();
+        }
+        Reference<StreamAllocation> reference = this.connection.allocations.get(0);
+        Socket deallocate = deallocate(true, false, false);
+        this.connection = realConnection;
+        realConnection.allocations.add(reference);
+        return deallocate;
+    }
+
+    public boolean hasMoreRoutes() {
+        RouteSelector.Selection selection;
+        return this.route != null || ((selection = this.routeSelection) != null && selection.hasNext()) || this.routeSelector.hasNext();
+    }
+
+    public String toString() {
+        RealConnection connection = connection();
+        return connection != null ? connection.toString() : this.address.toString();
+    }
+
+    public static final class StreamAllocationReference extends WeakReference<StreamAllocation> {
+        public final Object callStackTrace;
+
+        public StreamAllocationReference(StreamAllocation streamAllocation, Object obj) {
+            super(streamAllocation);
+            this.callStackTrace = obj;
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/thrid/okhttp/internal/http/BridgeInterceptor.java

@@ -0,0 +1,91 @@
+package com.mbridge.msdk.thrid.okhttp.internal.http;
+
+import com.ironsource.nb;
+import com.mbridge.msdk.foundation.download.Command;
+import com.mbridge.msdk.thrid.okhttp.Cookie;
+import com.mbridge.msdk.thrid.okhttp.CookieJar;
+import com.mbridge.msdk.thrid.okhttp.Interceptor;
+import com.mbridge.msdk.thrid.okhttp.MediaType;
+import com.mbridge.msdk.thrid.okhttp.Request;
+import com.mbridge.msdk.thrid.okhttp.RequestBody;
+import com.mbridge.msdk.thrid.okhttp.Response;
+import com.mbridge.msdk.thrid.okhttp.internal.Util;
+import com.mbridge.msdk.thrid.okhttp.internal.Version;
+import com.mbridge.msdk.thrid.okio.GzipSource;
+import com.mbridge.msdk.thrid.okio.Okio;
+import java.io.IOException;
+import java.util.List;
+import org.apache.http.cookie.SM;
+import org.apache.http.protocol.HTTP;
+
+/* loaded from: classes4.dex */
+public final class BridgeInterceptor implements Interceptor {
+    private final CookieJar cookieJar;
+
+    public BridgeInterceptor(CookieJar cookieJar) {
+        this.cookieJar = cookieJar;
+    }
+
+    @Override // com.mbridge.msdk.thrid.okhttp.Interceptor
+    public Response intercept(Interceptor.Chain chain) throws IOException {
+        Request request = chain.request();
+        Request.Builder newBuilder = request.newBuilder();
+        RequestBody body = request.body();
+        if (body != null) {
+            MediaType contentType = body.contentType();
+            if (contentType != null) {
+                newBuilder.header("Content-Type", contentType.toString());
+            }
+            long contentLength = body.contentLength();
+            if (contentLength != -1) {
+                newBuilder.header(HTTP.CONTENT_LEN, Long.toString(contentLength));
+                newBuilder.removeHeader(HTTP.TRANSFER_ENCODING);
+            } else {
+                newBuilder.header(HTTP.TRANSFER_ENCODING, HTTP.CHUNK_CODING);
+                newBuilder.removeHeader(HTTP.CONTENT_LEN);
+            }
+        }
+        boolean z = false;
+        if (request.header(HTTP.TARGET_HOST) == null) {
+            newBuilder.header(HTTP.TARGET_HOST, Util.hostHeader(request.url(), false));
+        }
+        if (request.header(HTTP.CONN_DIRECTIVE) == null) {
+            newBuilder.header(HTTP.CONN_DIRECTIVE, HTTP.CONN_KEEP_ALIVE);
+        }
+        if (request.header("Accept-Encoding") == null && request.header(Command.HTTP_HEADER_RANGE) == null) {
+            newBuilder.header("Accept-Encoding", "gzip");
+            z = true;
+        }
+        List<Cookie> loadForRequest = this.cookieJar.loadForRequest(request.url());
+        if (!loadForRequest.isEmpty()) {
+            newBuilder.header(SM.COOKIE, cookieHeader(loadForRequest));
+        }
+        if (request.header("User-Agent") == null) {
+            newBuilder.header("User-Agent", Version.userAgent());
+        }
+        Response proceed = chain.proceed(newBuilder.build());
+        HttpHeaders.receiveHeaders(this.cookieJar, request.url(), proceed.headers());
+        Response.Builder request2 = proceed.newBuilder().request(request);
+        if (z && "gzip".equalsIgnoreCase(proceed.header(HTTP.CONTENT_ENCODING)) && HttpHeaders.hasBody(proceed)) {
+            GzipSource gzipSource = new GzipSource(proceed.body().source());
+            request2.headers(proceed.headers().newBuilder().removeAll(HTTP.CONTENT_ENCODING).removeAll(HTTP.CONTENT_LEN).build());
+            request2.body(new RealResponseBody(proceed.header("Content-Type"), -1L, Okio.buffer(gzipSource)));
+        }
+        return request2.build();
+    }
+
+    private String cookieHeader(List<Cookie> list) {
+        StringBuilder sb = new StringBuilder();
+        int size = list.size();
+        for (int i = 0; i < size; i++) {
+            if (i > 0) {
+                sb.append("; ");
+            }
+            Cookie cookie = list.get(i);
+            sb.append(cookie.name());
+            sb.append(nb.T);
+            sb.append(cookie.value());
+        }
+        return sb.toString();
+    }
+}

decompiled/sources/com/mbridge/msdk/thrid/okhttp/internal/http/CallServerInterceptor.java

@@ -0,0 +1,95 @@
+package com.mbridge.msdk.thrid.okhttp.internal.http;
+
+import com.mbridge.msdk.thrid.okhttp.Interceptor;
+import com.mbridge.msdk.thrid.okhttp.Request;
+import com.mbridge.msdk.thrid.okhttp.Response;
+import com.mbridge.msdk.thrid.okhttp.internal.Util;
+import com.mbridge.msdk.thrid.okhttp.internal.connection.RealConnection;
+import com.mbridge.msdk.thrid.okhttp.internal.connection.StreamAllocation;
+import com.mbridge.msdk.thrid.okio.Buffer;
+import com.mbridge.msdk.thrid.okio.BufferedSink;
+import com.mbridge.msdk.thrid.okio.ForwardingSink;
+import com.mbridge.msdk.thrid.okio.Okio;
+import com.mbridge.msdk.thrid.okio.Sink;
+import java.io.IOException;
+import java.net.ProtocolException;
+import org.apache.http.protocol.HTTP;
+
+/* loaded from: classes4.dex */
+public final class CallServerInterceptor implements Interceptor {
+    private final boolean forWebSocket;
+
+    public CallServerInterceptor(boolean z) {
+        this.forWebSocket = z;
+    }
+
+    @Override // com.mbridge.msdk.thrid.okhttp.Interceptor
+    public Response intercept(Interceptor.Chain chain) throws IOException {
+        Response build;
+        RealInterceptorChain realInterceptorChain = (RealInterceptorChain) chain;
+        HttpCodec httpStream = realInterceptorChain.httpStream();
+        StreamAllocation streamAllocation = realInterceptorChain.streamAllocation();
+        RealConnection realConnection = (RealConnection) realInterceptorChain.connection();
+        Request request = realInterceptorChain.request();
+        long currentTimeMillis = System.currentTimeMillis();
+        realInterceptorChain.eventListener().requestHeadersStart(realInterceptorChain.call());
+        httpStream.writeRequestHeaders(request);
+        realInterceptorChain.eventListener().requestHeadersEnd(realInterceptorChain.call(), request);
+        Response.Builder builder = null;
+        if (HttpMethod.permitsRequestBody(request.method()) && request.body() != null) {
+            if (HTTP.EXPECT_CONTINUE.equalsIgnoreCase(request.header(HTTP.EXPECT_DIRECTIVE))) {
+                httpStream.flushRequest();
+                realInterceptorChain.eventListener().responseHeadersStart(realInterceptorChain.call());
+                builder = httpStream.readResponseHeaders(true);
+            }
+            if (builder == null) {
+                realInterceptorChain.eventListener().requestBodyStart(realInterceptorChain.call());
+                CountingSink countingSink = new CountingSink(httpStream.createRequestBody(request, request.body().contentLength()));
+                BufferedSink buffer = Okio.buffer(countingSink);
+                request.body().writeTo(buffer);
+                buffer.close();
+                realInterceptorChain.eventListener().requestBodyEnd(realInterceptorChain.call(), countingSink.successfulCount);
+            } else if (!realConnection.isMultiplexed()) {
+                streamAllocation.noNewStreams();
+            }
+        }
+        httpStream.finishRequest();
+        if (builder == null) {
+            realInterceptorChain.eventListener().responseHeadersStart(realInterceptorChain.call());
+            builder = httpStream.readResponseHeaders(false);
+        }
+        Response build2 = builder.request(request).handshake(streamAllocation.connection().handshake()).sentRequestAtMillis(currentTimeMillis).receivedResponseAtMillis(System.currentTimeMillis()).build();
+        int code = build2.code();
+        if (code == 100) {
+            build2 = httpStream.readResponseHeaders(false).request(request).handshake(streamAllocation.connection().handshake()).sentRequestAtMillis(currentTimeMillis).receivedResponseAtMillis(System.currentTimeMillis()).build();
+            code = build2.code();
+        }
+        realInterceptorChain.eventListener().responseHeadersEnd(realInterceptorChain.call(), build2);
+        if (this.forWebSocket && code == 101) {
+            build = build2.newBuilder().body(Util.EMPTY_RESPONSE).build();
+        } else {
+            build = build2.newBuilder().body(httpStream.openResponseBody(build2)).build();
+        }
+        if ("close".equalsIgnoreCase(build.request().header(HTTP.CONN_DIRECTIVE)) || "close".equalsIgnoreCase(build.header(HTTP.CONN_DIRECTIVE))) {
+            streamAllocation.noNewStreams();
+        }
+        if ((code != 204 && code != 205) || build.body().contentLength() <= 0) {
+            return build;
+        }
+        throw new ProtocolException("HTTP " + code + " had non-zero Content-Length: " + build.body().contentLength());
+    }
+
+    public static final class CountingSink extends ForwardingSink {
+        long successfulCount;
+
+        public CountingSink(Sink sink) {
+            super(sink);
+        }
+
+        @Override // com.mbridge.msdk.thrid.okio.ForwardingSink, com.mbridge.msdk.thrid.okio.Sink
+        public void write(Buffer buffer, long j) throws IOException {
+            super.write(buffer, j);
+            this.successfulCount += j;
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/thrid/okhttp/internal/http/HttpCodec.java

@@ -0,0 +1,26 @@
+package com.mbridge.msdk.thrid.okhttp.internal.http;
+
+import com.mbridge.msdk.thrid.okhttp.Request;
+import com.mbridge.msdk.thrid.okhttp.Response;
+import com.mbridge.msdk.thrid.okhttp.ResponseBody;
+import com.mbridge.msdk.thrid.okio.Sink;
+import java.io.IOException;
+
+/* loaded from: classes4.dex */
+public interface HttpCodec {
+    public static final int DISCARD_STREAM_TIMEOUT_MILLIS = 100;
+
+    void cancel();
+
+    Sink createRequestBody(Request request, long j);
+
+    void finishRequest() throws IOException;
+
+    void flushRequest() throws IOException;
+
+    ResponseBody openResponseBody(Response response) throws IOException;
+
+    Response.Builder readResponseHeaders(boolean z) throws IOException;
+
+    void writeRequestHeaders(Request request) throws IOException;
+}

decompiled/sources/com/mbridge/msdk/thrid/okhttp/internal/http/HttpDate.java

@@ -0,0 +1,72 @@
+package com.mbridge.msdk.thrid.okhttp.internal.http;
+
+import com.mbridge.msdk.thrid.okhttp.internal.Util;
+import java.text.DateFormat;
+import java.text.ParsePosition;
+import java.text.SimpleDateFormat;
+import java.util.Date;
+import java.util.Locale;
+import org.apache.http.impl.cookie.DateUtils;
+
+/* loaded from: classes4.dex */
+public final class HttpDate {
+    private static final DateFormat[] BROWSER_COMPATIBLE_DATE_FORMATS;
+    private static final String[] BROWSER_COMPATIBLE_DATE_FORMAT_STRINGS;
+    public static final long MAX_DATE = 253402300799999L;
+    private static final ThreadLocal<DateFormat> STANDARD_DATE_FORMAT = new ThreadLocal<DateFormat>() { // from class: com.mbridge.msdk.thrid.okhttp.internal.http.HttpDate.1
+        @Override // java.lang.ThreadLocal
+        public DateFormat initialValue() {
+            SimpleDateFormat simpleDateFormat = new SimpleDateFormat("EEE, dd MMM yyyy HH:mm:ss 'GMT'", Locale.US);
+            simpleDateFormat.setLenient(false);
+            simpleDateFormat.setTimeZone(Util.UTC);
+            return simpleDateFormat;
+        }
+    };
+
+    static {
+        String[] strArr = {"EEE, dd MMM yyyy HH:mm:ss zzz", DateUtils.PATTERN_RFC1036, DateUtils.PATTERN_ASCTIME, "EEE, dd-MMM-yyyy HH:mm:ss z", "EEE, dd-MMM-yyyy HH-mm-ss z", "EEE, dd MMM yy HH:mm:ss z", "EEE dd-MMM-yyyy HH:mm:ss z", "EEE dd MMM yyyy HH:mm:ss z", "EEE dd-MMM-yyyy HH-mm-ss z", "EEE dd-MMM-yy HH:mm:ss z", "EEE dd MMM yy HH:mm:ss z", "EEE,dd-MMM-yy HH:mm:ss z", "EEE,dd-MMM-yyyy HH:mm:ss z", "EEE, dd-MM-yyyy HH:mm:ss z", "EEE MMM d yyyy HH:mm:ss z"};
+        BROWSER_COMPATIBLE_DATE_FORMAT_STRINGS = strArr;
+        BROWSER_COMPATIBLE_DATE_FORMATS = new DateFormat[strArr.length];
+    }
+
+    public static Date parse(String str) {
+        if (str.length() == 0) {
+            return null;
+        }
+        ParsePosition parsePosition = new ParsePosition(0);
+        Date parse = STANDARD_DATE_FORMAT.get().parse(str, parsePosition);
+        if (parsePosition.getIndex() == str.length()) {
+            return parse;
+        }
+        String[] strArr = BROWSER_COMPATIBLE_DATE_FORMAT_STRINGS;
+        synchronized (strArr) {
+            try {
+                int length = strArr.length;
+                for (int i = 0; i < length; i++) {
+                    DateFormat[] dateFormatArr = BROWSER_COMPATIBLE_DATE_FORMATS;
+                    DateFormat dateFormat = dateFormatArr[i];
+                    if (dateFormat == null) {
+                        dateFormat = new SimpleDateFormat(BROWSER_COMPATIBLE_DATE_FORMAT_STRINGS[i], Locale.US);
+                        dateFormat.setTimeZone(Util.UTC);
+                        dateFormatArr[i] = dateFormat;
+                    }
+                    parsePosition.setIndex(0);
+                    Date parse2 = dateFormat.parse(str, parsePosition);
+                    if (parsePosition.getIndex() != 0) {
+                        return parse2;
+                    }
+                }
+                return null;
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+    }
+
+    public static String format(Date date) {
+        return STANDARD_DATE_FORMAT.get().format(date);
+    }
+
+    private HttpDate() {
+    }
+}

decompiled/sources/com/mbridge/msdk/thrid/okhttp/internal/http/HttpHeaders.java

@@ -0,0 +1,357 @@
+package com.mbridge.msdk.thrid.okhttp.internal.http;
+
+import androidx.webkit.ProxyConfig;
+import com.mbridge.msdk.thrid.okhttp.Challenge;
+import com.mbridge.msdk.thrid.okhttp.Cookie;
+import com.mbridge.msdk.thrid.okhttp.CookieJar;
+import com.mbridge.msdk.thrid.okhttp.Headers;
+import com.mbridge.msdk.thrid.okhttp.HttpUrl;
+import com.mbridge.msdk.thrid.okhttp.Request;
+import com.mbridge.msdk.thrid.okhttp.Response;
+import com.mbridge.msdk.thrid.okhttp.internal.Util;
+import com.mbridge.msdk.thrid.okio.Buffer;
+import com.mbridge.msdk.thrid.okio.ByteString;
+import java.io.EOFException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+import java.util.Set;
+import java.util.TreeSet;
+import org.apache.http.client.methods.HttpHead;
+import org.apache.http.message.BasicHeaderValueFormatter;
+import org.apache.http.protocol.HTTP;
+
+/* loaded from: classes4.dex */
+public final class HttpHeaders {
+    private static final ByteString QUOTED_STRING_DELIMITERS = ByteString.encodeUtf8(BasicHeaderValueFormatter.UNSAFE_CHARS);
+    private static final ByteString TOKEN_DELIMITERS = ByteString.encodeUtf8("\t ,=");
+
+    private HttpHeaders() {
+    }
+
+    public static long contentLength(Response response) {
+        return contentLength(response.headers());
+    }
+
+    public static long contentLength(Headers headers) {
+        return stringToLong(headers.get(HTTP.CONTENT_LEN));
+    }
+
+    private static long stringToLong(String str) {
+        if (str == null) {
+            return -1L;
+        }
+        try {
+            return Long.parseLong(str);
+        } catch (NumberFormatException unused) {
+            return -1L;
+        }
+    }
+
+    public static boolean varyMatches(Response response, Headers headers, Request request) {
+        for (String str : varyFields(response)) {
+            if (!Util.equal(headers.values(str), request.headers(str))) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    public static boolean hasVaryAll(Response response) {
+        return hasVaryAll(response.headers());
+    }
+
+    public static boolean hasVaryAll(Headers headers) {
+        return varyFields(headers).contains(ProxyConfig.MATCH_ALL_SCHEMES);
+    }
+
+    private static Set<String> varyFields(Response response) {
+        return varyFields(response.headers());
+    }
+
+    public static Set<String> varyFields(Headers headers) {
+        Set<String> emptySet = Collections.emptySet();
+        int size = headers.size();
+        for (int i = 0; i < size; i++) {
+            if ("Vary".equalsIgnoreCase(headers.name(i))) {
+                String value = headers.value(i);
+                if (emptySet.isEmpty()) {
+                    emptySet = new TreeSet<>((Comparator<? super String>) String.CASE_INSENSITIVE_ORDER);
+                }
+                for (String str : value.split(",")) {
+                    emptySet.add(str.trim());
+                }
+            }
+        }
+        return emptySet;
+    }
+
+    public static Headers varyHeaders(Response response) {
+        return varyHeaders(response.networkResponse().request().headers(), response.headers());
+    }
+
+    public static Headers varyHeaders(Headers headers, Headers headers2) {
+        Set<String> varyFields = varyFields(headers2);
+        if (varyFields.isEmpty()) {
+            return new Headers.Builder().build();
+        }
+        Headers.Builder builder = new Headers.Builder();
+        int size = headers.size();
+        for (int i = 0; i < size; i++) {
+            String name = headers.name(i);
+            if (varyFields.contains(name)) {
+                builder.add(name, headers.value(i));
+            }
+        }
+        return builder.build();
+    }
+
+    public static List<Challenge> parseChallenges(Headers headers, String str) {
+        ArrayList arrayList = new ArrayList();
+        for (int i = 0; i < headers.size(); i++) {
+            if (str.equalsIgnoreCase(headers.name(i))) {
+                parseChallengeHeader(arrayList, new Buffer().writeUtf8(headers.value(i)));
+            }
+        }
+        return arrayList;
+    }
+
+    /* JADX WARN: Code restructure failed: missing block: B:24:0x007d, code lost:
+    
+        continue;
+     */
+    /* JADX WARN: Code restructure failed: missing block: B:57:0x007d, code lost:
+    
+        continue;
+     */
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    private static void parseChallengeHeader(java.util.List<com.mbridge.msdk.thrid.okhttp.Challenge> r8, com.mbridge.msdk.thrid.okio.Buffer r9) {
+        /*
+            r0 = 0
+        L1:
+            r1 = r0
+        L2:
+            if (r1 != 0) goto Le
+            skipWhitespaceAndCommas(r9)
+            java.lang.String r1 = readToken(r9)
+            if (r1 != 0) goto Le
+            return
+        Le:
+            boolean r2 = skipWhitespaceAndCommas(r9)
+            java.lang.String r3 = readToken(r9)
+            if (r3 != 0) goto L2c
+            boolean r9 = r9.exhausted()
+            if (r9 != 0) goto L1f
+            return
+        L1f:
+            com.mbridge.msdk.thrid.okhttp.Challenge r9 = new com.mbridge.msdk.thrid.okhttp.Challenge
+            java.util.Map r0 = java.util.Collections.emptyMap()
+            r9.<init>(r1, r0)
+            r8.add(r9)
+            return
+        L2c:
+            r4 = 61
+            int r5 = skipAll(r9, r4)
+            boolean r6 = skipWhitespaceAndCommas(r9)
+            if (r2 != 0) goto L60
+            if (r6 != 0) goto L40
+            boolean r2 = r9.exhausted()
+            if (r2 == 0) goto L60
+        L40:
+            com.mbridge.msdk.thrid.okhttp.Challenge r2 = new com.mbridge.msdk.thrid.okhttp.Challenge
+            java.lang.StringBuilder r6 = new java.lang.StringBuilder
+            r6.<init>()
+            r6.append(r3)
+            java.lang.String r3 = repeat(r4, r5)
+            r6.append(r3)
+            java.lang.String r3 = r6.toString()
+            java.util.Map r3 = java.util.Collections.singletonMap(r0, r3)
+            r2.<init>(r1, r3)
+            r8.add(r2)
+            goto L1
+        L60:
+            java.util.LinkedHashMap r2 = new java.util.LinkedHashMap
+            r2.<init>()
+            int r6 = skipAll(r9, r4)
+            int r5 = r5 + r6
+        L6a:
+            if (r3 != 0) goto L7b
+            java.lang.String r3 = readToken(r9)
+            boolean r5 = skipWhitespaceAndCommas(r9)
+            if (r5 == 0) goto L77
+            goto L7d
+        L77:
+            int r5 = skipAll(r9, r4)
+        L7b:
+            if (r5 != 0) goto L88
+        L7d:
+            com.mbridge.msdk.thrid.okhttp.Challenge r4 = new com.mbridge.msdk.thrid.okhttp.Challenge
+            r4.<init>(r1, r2)
+            r8.add(r4)
+            r1 = r3
+            goto L2
+        L88:
+            r6 = 1
+            if (r5 <= r6) goto L8c
+            return
+        L8c:
+            boolean r6 = skipWhitespaceAndCommas(r9)
+            if (r6 == 0) goto L93
+            return
+        L93:
+            boolean r6 = r9.exhausted()
+            if (r6 != 0) goto La8
+            r6 = 0
+            byte r6 = r9.getByte(r6)
+            r7 = 34
+            if (r6 != r7) goto La8
+            java.lang.String r6 = readQuotedString(r9)
+            goto Lac
+        La8:
+            java.lang.String r6 = readToken(r9)
+        Lac:
+            if (r6 != 0) goto Laf
+            return
+        Laf:
+            java.lang.Object r3 = r2.put(r3, r6)
+            java.lang.String r3 = (java.lang.String) r3
+            if (r3 == 0) goto Lb8
+            return
+        Lb8:
+            boolean r3 = skipWhitespaceAndCommas(r9)
+            if (r3 != 0) goto Lc5
+            boolean r3 = r9.exhausted()
+            if (r3 != 0) goto Lc5
+            return
+        Lc5:
+            r3 = r0
+            goto L6a
+        */
+        throw new UnsupportedOperationException("Method not decompiled: com.mbridge.msdk.thrid.okhttp.internal.http.HttpHeaders.parseChallengeHeader(java.util.List, com.mbridge.msdk.thrid.okio.Buffer):void");
+    }
+
+    private static boolean skipWhitespaceAndCommas(Buffer buffer) {
+        boolean z = false;
+        while (!buffer.exhausted()) {
+            byte b = buffer.getByte(0L);
+            if (b != 44) {
+                if (b != 32 && b != 9) {
+                    break;
+                }
+                buffer.readByte();
+            } else {
+                buffer.readByte();
+                z = true;
+            }
+        }
+        return z;
+    }
+
+    private static int skipAll(Buffer buffer, byte b) {
+        int i = 0;
+        while (!buffer.exhausted() && buffer.getByte(0L) == b) {
+            i++;
+            buffer.readByte();
+        }
+        return i;
+    }
+
+    private static String readQuotedString(Buffer buffer) {
+        if (buffer.readByte() != 34) {
+            throw new IllegalArgumentException();
+        }
+        Buffer buffer2 = new Buffer();
+        while (true) {
+            long indexOfElement = buffer.indexOfElement(QUOTED_STRING_DELIMITERS);
+            if (indexOfElement == -1) {
+                return null;
+            }
+            if (buffer.getByte(indexOfElement) == 34) {
+                buffer2.write(buffer, indexOfElement);
+                buffer.readByte();
+                return buffer2.readUtf8();
+            }
+            if (buffer.size() == indexOfElement + 1) {
+                return null;
+            }
+            buffer2.write(buffer, indexOfElement);
+            buffer.readByte();
+            buffer2.write(buffer, 1L);
+        }
+    }
+
+    private static String readToken(Buffer buffer) {
+        try {
+            long indexOfElement = buffer.indexOfElement(TOKEN_DELIMITERS);
+            if (indexOfElement == -1) {
+                indexOfElement = buffer.size();
+            }
+            if (indexOfElement != 0) {
+                return buffer.readUtf8(indexOfElement);
+            }
+            return null;
+        } catch (EOFException unused) {
+            throw new AssertionError();
+        }
+    }
+
+    private static String repeat(char c, int i) {
+        char[] cArr = new char[i];
+        Arrays.fill(cArr, c);
+        return new String(cArr);
+    }
+
+    public static void receiveHeaders(CookieJar cookieJar, HttpUrl httpUrl, Headers headers) {
+        if (cookieJar == CookieJar.NO_COOKIES) {
+            return;
+        }
+        List<Cookie> parseAll = Cookie.parseAll(httpUrl, headers);
+        if (parseAll.isEmpty()) {
+            return;
+        }
+        cookieJar.saveFromResponse(httpUrl, parseAll);
+    }
+
+    public static boolean hasBody(Response response) {
+        if (response.request().method().equals(HttpHead.METHOD_NAME)) {
+            return false;
+        }
+        int code = response.code();
+        return (((code >= 100 && code < 200) || code == 204 || code == 304) && contentLength(response) == -1 && !HTTP.CHUNK_CODING.equalsIgnoreCase(response.header(HTTP.TRANSFER_ENCODING))) ? false : true;
+    }
+
+    public static int skipUntil(String str, int i, String str2) {
+        while (i < str.length() && str2.indexOf(str.charAt(i)) == -1) {
+            i++;
+        }
+        return i;
+    }
+
+    public static int skipWhitespace(String str, int i) {
+        char charAt;
+        while (i < str.length() && ((charAt = str.charAt(i)) == ' ' || charAt == '\t')) {
+            i++;
+        }
+        return i;
+    }
+
+    public static int parseSeconds(String str, int i) {
+        try {
+            long parseLong = Long.parseLong(str);
+            if (parseLong > 2147483647L) {
+                return Integer.MAX_VALUE;
+            }
+            if (parseLong < 0) {
+                return 0;
+            }
+            return (int) parseLong;
+        } catch (NumberFormatException unused) {
+            return i;
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/thrid/okhttp/internal/http/HttpMethod.java

@@ -0,0 +1,31 @@
+package com.mbridge.msdk.thrid.okhttp.internal.http;
+
+import org.apache.http.client.methods.HttpDelete;
+import org.apache.http.client.methods.HttpHead;
+import org.apache.http.client.methods.HttpPut;
+
+/* loaded from: classes4.dex */
+public final class HttpMethod {
+    public static boolean invalidatesCache(String str) {
+        return str.equals("POST") || str.equals("PATCH") || str.equals(HttpPut.METHOD_NAME) || str.equals(HttpDelete.METHOD_NAME) || str.equals("MOVE");
+    }
+
+    public static boolean requiresRequestBody(String str) {
+        return str.equals("POST") || str.equals(HttpPut.METHOD_NAME) || str.equals("PATCH") || str.equals("PROPPATCH") || str.equals("REPORT");
+    }
+
+    public static boolean permitsRequestBody(String str) {
+        return (str.equals("GET") || str.equals(HttpHead.METHOD_NAME)) ? false : true;
+    }
+
+    public static boolean redirectsWithBody(String str) {
+        return str.equals("PROPFIND");
+    }
+
+    public static boolean redirectsToGet(String str) {
+        return !str.equals("PROPFIND");
+    }
+
+    private HttpMethod() {
+    }
+}

decompiled/sources/com/mbridge/msdk/thrid/okhttp/internal/http/RealInterceptorChain.java

@@ -0,0 +1,132 @@
+package com.mbridge.msdk.thrid.okhttp.internal.http;
+
+import com.mbridge.msdk.thrid.okhttp.Call;
+import com.mbridge.msdk.thrid.okhttp.Connection;
+import com.mbridge.msdk.thrid.okhttp.EventListener;
+import com.mbridge.msdk.thrid.okhttp.Interceptor;
+import com.mbridge.msdk.thrid.okhttp.Request;
+import com.mbridge.msdk.thrid.okhttp.Response;
+import com.mbridge.msdk.thrid.okhttp.internal.Util;
+import com.mbridge.msdk.thrid.okhttp.internal.connection.RealConnection;
+import com.mbridge.msdk.thrid.okhttp.internal.connection.StreamAllocation;
+import java.io.IOException;
+import java.util.List;
+import java.util.concurrent.TimeUnit;
+
+/* loaded from: classes4.dex */
+public final class RealInterceptorChain implements Interceptor.Chain {
+    private final Call call;
+    private int calls;
+    private final int connectTimeout;
+    private final RealConnection connection;
+    private final EventListener eventListener;
+    private final HttpCodec httpCodec;
+    private final int index;
+    private final List<Interceptor> interceptors;
+    private final int readTimeout;
+    private final Request request;
+    private final StreamAllocation streamAllocation;
+    private final int writeTimeout;
+
+    @Override // com.mbridge.msdk.thrid.okhttp.Interceptor.Chain
+    public Call call() {
+        return this.call;
+    }
+
+    @Override // com.mbridge.msdk.thrid.okhttp.Interceptor.Chain
+    public int connectTimeoutMillis() {
+        return this.connectTimeout;
+    }
+
+    @Override // com.mbridge.msdk.thrid.okhttp.Interceptor.Chain
+    public Connection connection() {
+        return this.connection;
+    }
+
+    public EventListener eventListener() {
+        return this.eventListener;
+    }
+
+    public HttpCodec httpStream() {
+        return this.httpCodec;
+    }
+
+    @Override // com.mbridge.msdk.thrid.okhttp.Interceptor.Chain
+    public int readTimeoutMillis() {
+        return this.readTimeout;
+    }
+
+    @Override // com.mbridge.msdk.thrid.okhttp.Interceptor.Chain
+    public Request request() {
+        return this.request;
+    }
+
+    public StreamAllocation streamAllocation() {
+        return this.streamAllocation;
+    }
+
+    @Override // com.mbridge.msdk.thrid.okhttp.Interceptor.Chain
+    public int writeTimeoutMillis() {
+        return this.writeTimeout;
+    }
+
+    public RealInterceptorChain(List<Interceptor> list, StreamAllocation streamAllocation, HttpCodec httpCodec, RealConnection realConnection, int i, Request request, Call call, EventListener eventListener, int i2, int i3, int i4) {
+        this.interceptors = list;
+        this.connection = realConnection;
+        this.streamAllocation = streamAllocation;
+        this.httpCodec = httpCodec;
+        this.index = i;
+        this.request = request;
+        this.call = call;
+        this.eventListener = eventListener;
+        this.connectTimeout = i2;
+        this.readTimeout = i3;
+        this.writeTimeout = i4;
+    }
+
+    @Override // com.mbridge.msdk.thrid.okhttp.Interceptor.Chain
+    public Interceptor.Chain withConnectTimeout(int i, TimeUnit timeUnit) {
+        return new RealInterceptorChain(this.interceptors, this.streamAllocation, this.httpCodec, this.connection, this.index, this.request, this.call, this.eventListener, Util.checkDuration("timeout", i, timeUnit), this.readTimeout, this.writeTimeout);
+    }
+
+    @Override // com.mbridge.msdk.thrid.okhttp.Interceptor.Chain
+    public Interceptor.Chain withReadTimeout(int i, TimeUnit timeUnit) {
+        return new RealInterceptorChain(this.interceptors, this.streamAllocation, this.httpCodec, this.connection, this.index, this.request, this.call, this.eventListener, this.connectTimeout, Util.checkDuration("timeout", i, timeUnit), this.writeTimeout);
+    }
+
+    @Override // com.mbridge.msdk.thrid.okhttp.Interceptor.Chain
+    public Interceptor.Chain withWriteTimeout(int i, TimeUnit timeUnit) {
+        return new RealInterceptorChain(this.interceptors, this.streamAllocation, this.httpCodec, this.connection, this.index, this.request, this.call, this.eventListener, this.connectTimeout, this.readTimeout, Util.checkDuration("timeout", i, timeUnit));
+    }
+
+    @Override // com.mbridge.msdk.thrid.okhttp.Interceptor.Chain
+    public Response proceed(Request request) throws IOException {
+        return proceed(request, this.streamAllocation, this.httpCodec, this.connection);
+    }
+
+    public Response proceed(Request request, StreamAllocation streamAllocation, HttpCodec httpCodec, RealConnection realConnection) throws IOException {
+        if (this.index >= this.interceptors.size()) {
+            throw new AssertionError();
+        }
+        this.calls++;
+        if (this.httpCodec != null && !this.connection.supportsUrl(request.url())) {
+            throw new IllegalStateException("network interceptor " + this.interceptors.get(this.index - 1) + " must retain the same host and port");
+        }
+        if (this.httpCodec != null && this.calls > 1) {
+            throw new IllegalStateException("network interceptor " + this.interceptors.get(this.index - 1) + " must call proceed() exactly once");
+        }
+        RealInterceptorChain realInterceptorChain = new RealInterceptorChain(this.interceptors, streamAllocation, httpCodec, realConnection, this.index + 1, request, this.call, this.eventListener, this.connectTimeout, this.readTimeout, this.writeTimeout);
+        Interceptor interceptor = this.interceptors.get(this.index);
+        Response intercept = interceptor.intercept(realInterceptorChain);
+        if (httpCodec != null && this.index + 1 < this.interceptors.size() && realInterceptorChain.calls != 1) {
+            throw new IllegalStateException("network interceptor " + interceptor + " must call proceed() exactly once");
+        }
+        if (intercept == null) {
+            throw new NullPointerException("interceptor " + interceptor + " returned null");
+        }
+        if (intercept.body() != null) {
+            return intercept;
+        }
+        throw new IllegalStateException("interceptor " + interceptor + " returned a response with no body");
+    }
+}

decompiled/sources/com/mbridge/msdk/thrid/okhttp/internal/http/RealResponseBody.java

@@ -0,0 +1,37 @@
+package com.mbridge.msdk.thrid.okhttp.internal.http;
+
+import com.mbridge.msdk.thrid.okhttp.MediaType;
+import com.mbridge.msdk.thrid.okhttp.ResponseBody;
+import com.mbridge.msdk.thrid.okio.BufferedSource;
+
+/* loaded from: classes4.dex */
+public final class RealResponseBody extends ResponseBody {
+    private final long contentLength;
+    private final String contentTypeString;
+    private final BufferedSource source;
+
+    @Override // com.mbridge.msdk.thrid.okhttp.ResponseBody
+    public long contentLength() {
+        return this.contentLength;
+    }
+
+    @Override // com.mbridge.msdk.thrid.okhttp.ResponseBody
+    public BufferedSource source() {
+        return this.source;
+    }
+
+    public RealResponseBody(String str, long j, BufferedSource bufferedSource) {
+        this.contentTypeString = str;
+        this.contentLength = j;
+        this.source = bufferedSource;
+    }
+
+    @Override // com.mbridge.msdk.thrid.okhttp.ResponseBody
+    public MediaType contentType() {
+        String str = this.contentTypeString;
+        if (str != null) {
+            return MediaType.parse(str);
+        }
+        return null;
+    }
+}

decompiled/sources/com/mbridge/msdk/thrid/okhttp/internal/http/RequestLine.java

@@ -0,0 +1,37 @@
+package com.mbridge.msdk.thrid.okhttp.internal.http;
+
+import com.mbridge.msdk.thrid.okhttp.HttpUrl;
+import com.mbridge.msdk.thrid.okhttp.Request;
+import java.net.Proxy;
+
+/* loaded from: classes4.dex */
+public final class RequestLine {
+    private RequestLine() {
+    }
+
+    public static String get(Request request, Proxy.Type type) {
+        StringBuilder sb = new StringBuilder();
+        sb.append(request.method());
+        sb.append(' ');
+        if (includeAuthorityInRequestLine(request, type)) {
+            sb.append(request.url());
+        } else {
+            sb.append(requestPath(request.url()));
+        }
+        sb.append(" HTTP/1.1");
+        return sb.toString();
+    }
+
+    private static boolean includeAuthorityInRequestLine(Request request, Proxy.Type type) {
+        return !request.isHttps() && type == Proxy.Type.HTTP;
+    }
+
+    public static String requestPath(HttpUrl httpUrl) {
+        String encodedPath = httpUrl.encodedPath();
+        String encodedQuery = httpUrl.encodedQuery();
+        if (encodedQuery == null) {
+            return encodedPath;
+        }
+        return encodedPath + '?' + encodedQuery;
+    }
+}

decompiled/sources/com/mbridge/msdk/thrid/okhttp/internal/http/RetryAndFollowUpInterceptor.java

@@ -0,0 +1,258 @@
+package com.mbridge.msdk.thrid.okhttp.internal.http;
+
+import com.mbridge.msdk.thrid.okhttp.Address;
+import com.mbridge.msdk.thrid.okhttp.Call;
+import com.mbridge.msdk.thrid.okhttp.CertificatePinner;
+import com.mbridge.msdk.thrid.okhttp.EventListener;
+import com.mbridge.msdk.thrid.okhttp.HttpUrl;
+import com.mbridge.msdk.thrid.okhttp.Interceptor;
+import com.mbridge.msdk.thrid.okhttp.OkHttpClient;
+import com.mbridge.msdk.thrid.okhttp.Request;
+import com.mbridge.msdk.thrid.okhttp.Response;
+import com.mbridge.msdk.thrid.okhttp.Route;
+import com.mbridge.msdk.thrid.okhttp.internal.Util;
+import com.mbridge.msdk.thrid.okhttp.internal.connection.RouteException;
+import com.mbridge.msdk.thrid.okhttp.internal.connection.StreamAllocation;
+import com.mbridge.msdk.thrid.okhttp.internal.http2.ConnectionShutdownException;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.io.InterruptedIOException;
+import java.net.HttpRetryException;
+import java.net.ProtocolException;
+import java.net.Proxy;
+import java.net.SocketTimeoutException;
+import java.security.cert.CertificateException;
+import javax.net.ssl.HostnameVerifier;
+import javax.net.ssl.SSLHandshakeException;
+import javax.net.ssl.SSLPeerUnverifiedException;
+import javax.net.ssl.SSLSocketFactory;
+import org.apache.http.HttpStatus;
+import org.apache.http.client.methods.HttpHead;
+import org.apache.http.protocol.HTTP;
+
+/* loaded from: classes4.dex */
+public final class RetryAndFollowUpInterceptor implements Interceptor {
+    private static final int MAX_FOLLOW_UPS = 20;
+    private Object callStackTrace;
+    private volatile boolean canceled;
+    private final OkHttpClient client;
+    private final boolean forWebSocket;
+    private volatile StreamAllocation streamAllocation;
+
+    public boolean isCanceled() {
+        return this.canceled;
+    }
+
+    public void setCallStackTrace(Object obj) {
+        this.callStackTrace = obj;
+    }
+
+    public StreamAllocation streamAllocation() {
+        return this.streamAllocation;
+    }
+
+    public RetryAndFollowUpInterceptor(OkHttpClient okHttpClient, boolean z) {
+        this.client = okHttpClient;
+        this.forWebSocket = z;
+    }
+
+    public void cancel() {
+        this.canceled = true;
+        StreamAllocation streamAllocation = this.streamAllocation;
+        if (streamAllocation != null) {
+            streamAllocation.cancel();
+        }
+    }
+
+    @Override // com.mbridge.msdk.thrid.okhttp.Interceptor
+    public Response intercept(Interceptor.Chain chain) throws IOException {
+        Response proceed;
+        Request followUpRequest;
+        Request request = chain.request();
+        RealInterceptorChain realInterceptorChain = (RealInterceptorChain) chain;
+        Call call = realInterceptorChain.call();
+        EventListener eventListener = realInterceptorChain.eventListener();
+        StreamAllocation streamAllocation = new StreamAllocation(this.client.connectionPool(), createAddress(request.url()), call, eventListener, this.callStackTrace);
+        this.streamAllocation = streamAllocation;
+        int i = 0;
+        Response response = null;
+        while (!this.canceled) {
+            try {
+                try {
+                    proceed = realInterceptorChain.proceed(request, streamAllocation, null, null);
+                    if (response != null) {
+                        proceed = proceed.newBuilder().priorResponse(response.newBuilder().body(null).build()).build();
+                    }
+                    try {
+                        followUpRequest = followUpRequest(proceed, streamAllocation.route());
+                    } catch (IOException e) {
+                        streamAllocation.release();
+                        throw e;
+                    }
+                } catch (RouteException e2) {
+                    if (!recover(e2.getLastConnectException(), streamAllocation, false, request)) {
+                        throw e2.getFirstConnectException();
+                    }
+                } catch (IOException e3) {
+                    if (!recover(e3, streamAllocation, !(e3 instanceof ConnectionShutdownException), request)) {
+                        throw e3;
+                    }
+                }
+                if (followUpRequest == null) {
+                    streamAllocation.release();
+                    return proceed;
+                }
+                Util.closeQuietly(proceed.body());
+                int i2 = i + 1;
+                if (i2 > 20) {
+                    streamAllocation.release();
+                    throw new ProtocolException("Too many follow-up requests: " + i2);
+                }
+                if (followUpRequest.body() instanceof UnrepeatableRequestBody) {
+                    streamAllocation.release();
+                    throw new HttpRetryException("Cannot retry streamed HTTP body", proceed.code());
+                }
+                if (!sameConnection(proceed, followUpRequest.url())) {
+                    streamAllocation.release();
+                    streamAllocation = new StreamAllocation(this.client.connectionPool(), createAddress(followUpRequest.url()), call, eventListener, this.callStackTrace);
+                    this.streamAllocation = streamAllocation;
+                } else if (streamAllocation.codec() != null) {
+                    throw new IllegalStateException("Closing the body of " + proceed + " didn't close its backing stream. Bad interceptor?");
+                }
+                response = proceed;
+                request = followUpRequest;
+                i = i2;
+            } catch (Throwable th) {
+                streamAllocation.streamFailed(null);
+                streamAllocation.release();
+                throw th;
+            }
+        }
+        streamAllocation.release();
+        throw new IOException("Canceled");
+    }
+
+    private Address createAddress(HttpUrl httpUrl) {
+        SSLSocketFactory sSLSocketFactory;
+        HostnameVerifier hostnameVerifier;
+        CertificatePinner certificatePinner;
+        if (httpUrl.isHttps()) {
+            sSLSocketFactory = this.client.sslSocketFactory();
+            hostnameVerifier = this.client.hostnameVerifier();
+            certificatePinner = this.client.certificatePinner();
+        } else {
+            sSLSocketFactory = null;
+            hostnameVerifier = null;
+            certificatePinner = null;
+        }
+        return new Address(httpUrl.host(), httpUrl.port(), this.client.dns(), this.client.socketFactory(), sSLSocketFactory, hostnameVerifier, certificatePinner, this.client.proxyAuthenticator(), this.client.proxy(), this.client.protocols(), this.client.connectionSpecs(), this.client.proxySelector());
+    }
+
+    private boolean recover(IOException iOException, StreamAllocation streamAllocation, boolean z, Request request) {
+        streamAllocation.streamFailed(iOException);
+        if (this.client.retryOnConnectionFailure()) {
+            return !(z && requestIsUnrepeatable(iOException, request)) && isRecoverable(iOException, z) && streamAllocation.hasMoreRoutes();
+        }
+        return false;
+    }
+
+    private boolean requestIsUnrepeatable(IOException iOException, Request request) {
+        return (request.body() instanceof UnrepeatableRequestBody) || (iOException instanceof FileNotFoundException);
+    }
+
+    private boolean isRecoverable(IOException iOException, boolean z) {
+        if (iOException instanceof ProtocolException) {
+            return false;
+        }
+        return iOException instanceof InterruptedIOException ? (iOException instanceof SocketTimeoutException) && !z : (((iOException instanceof SSLHandshakeException) && (iOException.getCause() instanceof CertificateException)) || (iOException instanceof SSLPeerUnverifiedException)) ? false : true;
+    }
+
+    private Request followUpRequest(Response response, Route route) throws IOException {
+        String header;
+        HttpUrl resolve;
+        if (response == null) {
+            throw new IllegalStateException();
+        }
+        int code = response.code();
+        String method = response.request().method();
+        if (code == 307 || code == 308) {
+            if (!method.equals("GET") && !method.equals(HttpHead.METHOD_NAME)) {
+                return null;
+            }
+        } else {
+            if (code == 401) {
+                return this.client.authenticator().authenticate(route, response);
+            }
+            if (code == 503) {
+                if ((response.priorResponse() == null || response.priorResponse().code() != 503) && retryAfter(response, Integer.MAX_VALUE) == 0) {
+                    return response.request();
+                }
+                return null;
+            }
+            if (code == 407) {
+                if (route.proxy().type() != Proxy.Type.HTTP) {
+                    throw new ProtocolException("Received HTTP_PROXY_AUTH (407) code while not using proxy");
+                }
+                return this.client.proxyAuthenticator().authenticate(route, response);
+            }
+            if (code == 408) {
+                if (!this.client.retryOnConnectionFailure() || (response.request().body() instanceof UnrepeatableRequestBody)) {
+                    return null;
+                }
+                if ((response.priorResponse() == null || response.priorResponse().code() != 408) && retryAfter(response, 0) <= 0) {
+                    return response.request();
+                }
+                return null;
+            }
+            switch (code) {
+                case 300:
+                case 301:
+                case 302:
+                case HttpStatus.SC_SEE_OTHER /* 303 */:
+                    break;
+                default:
+                    return null;
+            }
+        }
+        if (!this.client.followRedirects() || (header = response.header("Location")) == null || (resolve = response.request().url().resolve(header)) == null) {
+            return null;
+        }
+        if (!resolve.scheme().equals(response.request().url().scheme()) && !this.client.followSslRedirects()) {
+            return null;
+        }
+        Request.Builder newBuilder = response.request().newBuilder();
+        if (HttpMethod.permitsRequestBody(method)) {
+            boolean redirectsWithBody = HttpMethod.redirectsWithBody(method);
+            if (HttpMethod.redirectsToGet(method)) {
+                newBuilder.method("GET", null);
+            } else {
+                newBuilder.method(method, redirectsWithBody ? response.request().body() : null);
+            }
+            if (!redirectsWithBody) {
+                newBuilder.removeHeader(HTTP.TRANSFER_ENCODING);
+                newBuilder.removeHeader(HTTP.CONTENT_LEN);
+                newBuilder.removeHeader("Content-Type");
+            }
+        }
+        if (!sameConnection(response, resolve)) {
+            newBuilder.removeHeader("Authorization");
+        }
+        return newBuilder.url(resolve).build();
+    }
+
+    private int retryAfter(Response response, int i) {
+        String header = response.header("Retry-After");
+        if (header == null) {
+            return i;
+        }
+        if (header.matches("\\d+")) {
+            return Integer.valueOf(header).intValue();
+        }
+        return Integer.MAX_VALUE;
+    }
+
+    private boolean sameConnection(Response response, HttpUrl httpUrl) {
+        HttpUrl url = response.request().url();
+        return url.host().equals(httpUrl.host()) && url.port() == httpUrl.port() && url.scheme().equals(httpUrl.scheme());
+    }
+}

decompiled/sources/com/mbridge/msdk/thrid/okhttp/internal/http/StatusLine.java

@@ -0,0 +1,81 @@
+package com.mbridge.msdk.thrid.okhttp.internal.http;
+
+import com.mbridge.msdk.thrid.okhttp.Protocol;
+import com.mbridge.msdk.thrid.okhttp.Response;
+import java.io.IOException;
+import java.net.ProtocolException;
+
+/* loaded from: classes4.dex */
+public final class StatusLine {
+    public static final int HTTP_CONTINUE = 100;
+    public static final int HTTP_PERM_REDIRECT = 308;
+    public static final int HTTP_TEMP_REDIRECT = 307;
+    public final int code;
+    public final String message;
+    public final Protocol protocol;
+
+    public StatusLine(Protocol protocol, int i, String str) {
+        this.protocol = protocol;
+        this.code = i;
+        this.message = str;
+    }
+
+    public static StatusLine get(Response response) {
+        return new StatusLine(response.protocol(), response.code(), response.message());
+    }
+
+    public static StatusLine parse(String str) throws IOException {
+        Protocol protocol;
+        int i;
+        String str2;
+        if (str.startsWith("HTTP/1.")) {
+            i = 9;
+            if (str.length() < 9 || str.charAt(8) != ' ') {
+                throw new ProtocolException("Unexpected status line: " + str);
+            }
+            int charAt = str.charAt(7) - '0';
+            if (charAt == 0) {
+                protocol = Protocol.HTTP_1_0;
+            } else if (charAt == 1) {
+                protocol = Protocol.HTTP_1_1;
+            } else {
+                throw new ProtocolException("Unexpected status line: " + str);
+            }
+        } else if (str.startsWith("ICY ")) {
+            protocol = Protocol.HTTP_1_0;
+            i = 4;
+        } else {
+            throw new ProtocolException("Unexpected status line: " + str);
+        }
+        int i2 = i + 3;
+        if (str.length() < i2) {
+            throw new ProtocolException("Unexpected status line: " + str);
+        }
+        try {
+            int parseInt = Integer.parseInt(str.substring(i, i2));
+            if (str.length() <= i2) {
+                str2 = "";
+            } else {
+                if (str.charAt(i2) != ' ') {
+                    throw new ProtocolException("Unexpected status line: " + str);
+                }
+                str2 = str.substring(i + 4);
+            }
+            return new StatusLine(protocol, parseInt, str2);
+        } catch (NumberFormatException unused) {
+            throw new ProtocolException("Unexpected status line: " + str);
+        }
+    }
+
+    public String toString() {
+        StringBuilder sb = new StringBuilder();
+        sb.append(this.protocol == Protocol.HTTP_1_0 ? "HTTP/1.0" : "HTTP/1.1");
+        sb.append(' ');
+        sb.append(this.code);
+        if (this.message != null) {
+            sb.append(' ');
+            sb.append(this.message);
+        }
+        return sb.toString();
+    }
+}

decompiled/sources/com/mbridge/msdk/thrid/okhttp/internal/http/UnrepeatableRequestBody.java

@@ -0,0 +1,5 @@
+package com.mbridge.msdk.thrid.okhttp.internal.http;
+
+/* loaded from: classes4.dex */
+public interface UnrepeatableRequestBody {
+}

decompiled/sources/com/mbridge/msdk/thrid/okhttp/internal/http1/Http1Codec.java

@@ -0,0 +1,527 @@
+package com.mbridge.msdk.thrid.okhttp.internal.http1;
+
+import android.support.v4.media.session.PlaybackStateCompat;
+import com.mbridge.msdk.thrid.okhttp.Headers;
+import com.mbridge.msdk.thrid.okhttp.HttpUrl;
+import com.mbridge.msdk.thrid.okhttp.OkHttpClient;
+import com.mbridge.msdk.thrid.okhttp.Request;
+import com.mbridge.msdk.thrid.okhttp.Response;
+import com.mbridge.msdk.thrid.okhttp.ResponseBody;
+import com.mbridge.msdk.thrid.okhttp.internal.Internal;
+import com.mbridge.msdk.thrid.okhttp.internal.Util;
+import com.mbridge.msdk.thrid.okhttp.internal.connection.RealConnection;
+import com.mbridge.msdk.thrid.okhttp.internal.connection.StreamAllocation;
+import com.mbridge.msdk.thrid.okhttp.internal.http.HttpCodec;
+import com.mbridge.msdk.thrid.okhttp.internal.http.HttpHeaders;
+import com.mbridge.msdk.thrid.okhttp.internal.http.RealResponseBody;
+import com.mbridge.msdk.thrid.okhttp.internal.http.RequestLine;
+import com.mbridge.msdk.thrid.okhttp.internal.http.StatusLine;
+import com.mbridge.msdk.thrid.okio.Buffer;
+import com.mbridge.msdk.thrid.okio.BufferedSink;
+import com.mbridge.msdk.thrid.okio.BufferedSource;
+import com.mbridge.msdk.thrid.okio.ForwardingTimeout;
+import com.mbridge.msdk.thrid.okio.Okio;
+import com.mbridge.msdk.thrid.okio.Sink;
+import com.mbridge.msdk.thrid.okio.Source;
+import com.mbridge.msdk.thrid.okio.Timeout;
+import csdk.gluads.Consts;
+import java.io.EOFException;
+import java.io.IOException;
+import java.net.ProtocolException;
+import java.util.concurrent.TimeUnit;
+import org.apache.http.protocol.HTTP;
+
+/* loaded from: classes4.dex */
+public final class Http1Codec implements HttpCodec {
+    private static final int HEADER_LIMIT = 262144;
+    private static final int STATE_CLOSED = 6;
+    private static final int STATE_IDLE = 0;
+    private static final int STATE_OPEN_REQUEST_BODY = 1;
+    private static final int STATE_OPEN_RESPONSE_BODY = 4;
+    private static final int STATE_READING_RESPONSE_BODY = 5;
+    private static final int STATE_READ_RESPONSE_HEADERS = 3;
+    private static final int STATE_WRITING_REQUEST_BODY = 2;
+    final OkHttpClient client;
+    final BufferedSink sink;
+    final BufferedSource source;
+    final StreamAllocation streamAllocation;
+    int state = 0;
+    private long headerLimit = PlaybackStateCompat.ACTION_SET_REPEAT_MODE;
+
+    public boolean isClosed() {
+        return this.state == 6;
+    }
+
+    public Http1Codec(OkHttpClient okHttpClient, StreamAllocation streamAllocation, BufferedSource bufferedSource, BufferedSink bufferedSink) {
+        this.client = okHttpClient;
+        this.streamAllocation = streamAllocation;
+        this.source = bufferedSource;
+        this.sink = bufferedSink;
+    }
+
+    @Override // com.mbridge.msdk.thrid.okhttp.internal.http.HttpCodec
+    public Sink createRequestBody(Request request, long j) {
+        if (HTTP.CHUNK_CODING.equalsIgnoreCase(request.header(HTTP.TRANSFER_ENCODING))) {
+            return newChunkedSink();
+        }
+        if (j != -1) {
+            return newFixedLengthSink(j);
+        }
+        throw new IllegalStateException("Cannot stream a request body without chunked encoding or a known content length!");
+    }
+
+    @Override // com.mbridge.msdk.thrid.okhttp.internal.http.HttpCodec
+    public void cancel() {
+        RealConnection connection = this.streamAllocation.connection();
+        if (connection != null) {
+            connection.cancel();
+        }
+    }
+
+    @Override // com.mbridge.msdk.thrid.okhttp.internal.http.HttpCodec
+    public void writeRequestHeaders(Request request) throws IOException {
+        writeRequest(request.headers(), RequestLine.get(request, this.streamAllocation.connection().route().proxy().type()));
+    }
+
+    @Override // com.mbridge.msdk.thrid.okhttp.internal.http.HttpCodec
+    public ResponseBody openResponseBody(Response response) throws IOException {
+        StreamAllocation streamAllocation = this.streamAllocation;
+        streamAllocation.eventListener.responseBodyStart(streamAllocation.call);
+        String header = response.header("Content-Type");
+        if (!HttpHeaders.hasBody(response)) {
+            return new RealResponseBody(header, 0L, Okio.buffer(newFixedLengthSource(0L)));
+        }
+        if (HTTP.CHUNK_CODING.equalsIgnoreCase(response.header(HTTP.TRANSFER_ENCODING))) {
+            return new RealResponseBody(header, -1L, Okio.buffer(newChunkedSource(response.request().url())));
+        }
+        long contentLength = HttpHeaders.contentLength(response);
+        if (contentLength != -1) {
+            return new RealResponseBody(header, contentLength, Okio.buffer(newFixedLengthSource(contentLength)));
+        }
+        return new RealResponseBody(header, -1L, Okio.buffer(newUnknownLengthSource()));
+    }
+
+    @Override // com.mbridge.msdk.thrid.okhttp.internal.http.HttpCodec
+    public void flushRequest() throws IOException {
+        this.sink.flush();
+    }
+
+    @Override // com.mbridge.msdk.thrid.okhttp.internal.http.HttpCodec
+    public void finishRequest() throws IOException {
+        this.sink.flush();
+    }
+
+    public void writeRequest(Headers headers, String str) throws IOException {
+        if (this.state != 0) {
+            throw new IllegalStateException("state: " + this.state);
+        }
+        this.sink.writeUtf8(str).writeUtf8("\r\n");
+        int size = headers.size();
+        for (int i = 0; i < size; i++) {
+            this.sink.writeUtf8(headers.name(i)).writeUtf8(": ").writeUtf8(headers.value(i)).writeUtf8("\r\n");
+        }
+        this.sink.writeUtf8("\r\n");
+        this.state = 1;
+    }
+
+    @Override // com.mbridge.msdk.thrid.okhttp.internal.http.HttpCodec
+    public Response.Builder readResponseHeaders(boolean z) throws IOException {
+        int i = this.state;
+        if (i != 1 && i != 3) {
+            throw new IllegalStateException("state: " + this.state);
+        }
+        try {
+            StatusLine parse = StatusLine.parse(readHeaderLine());
+            Response.Builder headers = new Response.Builder().protocol(parse.protocol).code(parse.code).message(parse.message).headers(readHeaders());
+            if (z && parse.code == 100) {
+                return null;
+            }
+            if (parse.code == 100) {
+                this.state = 3;
+                return headers;
+            }
+            this.state = 4;
+            return headers;
+        } catch (EOFException e) {
+            IOException iOException = new IOException("unexpected end of stream on " + this.streamAllocation);
+            iOException.initCause(e);
+            throw iOException;
+        }
+    }
+
+    private String readHeaderLine() throws IOException {
+        String readUtf8LineStrict = this.source.readUtf8LineStrict(this.headerLimit);
+        this.headerLimit -= readUtf8LineStrict.length();
+        return readUtf8LineStrict;
+    }
+
+    public Headers readHeaders() throws IOException {
+        Headers.Builder builder = new Headers.Builder();
+        while (true) {
+            String readHeaderLine = readHeaderLine();
+            if (readHeaderLine.length() != 0) {
+                Internal.instance.addLenient(builder, readHeaderLine);
+            } else {
+                return builder.build();
+            }
+        }
+    }
+
+    public Sink newChunkedSink() {
+        if (this.state != 1) {
+            throw new IllegalStateException("state: " + this.state);
+        }
+        this.state = 2;
+        return new ChunkedSink();
+    }
+
+    public Sink newFixedLengthSink(long j) {
+        if (this.state != 1) {
+            throw new IllegalStateException("state: " + this.state);
+        }
+        this.state = 2;
+        return new FixedLengthSink(j);
+    }
+
+    public Source newFixedLengthSource(long j) throws IOException {
+        if (this.state != 4) {
+            throw new IllegalStateException("state: " + this.state);
+        }
+        this.state = 5;
+        return new FixedLengthSource(j);
+    }
+
+    public Source newChunkedSource(HttpUrl httpUrl) throws IOException {
+        if (this.state != 4) {
+            throw new IllegalStateException("state: " + this.state);
+        }
+        this.state = 5;
+        return new ChunkedSource(httpUrl);
+    }
+
+    public Source newUnknownLengthSource() throws IOException {
+        if (this.state != 4) {
+            throw new IllegalStateException("state: " + this.state);
+        }
+        StreamAllocation streamAllocation = this.streamAllocation;
+        if (streamAllocation == null) {
+            throw new IllegalStateException("streamAllocation == null");
+        }
+        this.state = 5;
+        streamAllocation.noNewStreams();
+        return new UnknownLengthSource();
+    }
+
+    public void detachTimeout(ForwardingTimeout forwardingTimeout) {
+        Timeout delegate = forwardingTimeout.delegate();
+        forwardingTimeout.setDelegate(Timeout.NONE);
+        delegate.clearDeadline();
+        delegate.clearTimeout();
+    }
+
+    public final class FixedLengthSink implements Sink {
+        private long bytesRemaining;
+        private boolean closed;
+        private final ForwardingTimeout timeout;
+
+        @Override // com.mbridge.msdk.thrid.okio.Sink
+        public Timeout timeout() {
+            return this.timeout;
+        }
+
+        public FixedLengthSink(long j) {
+            this.timeout = new ForwardingTimeout(Http1Codec.this.sink.timeout());
+            this.bytesRemaining = j;
+        }
+
+        @Override // com.mbridge.msdk.thrid.okio.Sink
+        public void write(Buffer buffer, long j) throws IOException {
+            if (this.closed) {
+                throw new IllegalStateException(Consts.PLACEMENT_STATUS_CLOSED);
+            }
+            Util.checkOffsetAndCount(buffer.size(), 0L, j);
+            if (j > this.bytesRemaining) {
+                throw new ProtocolException("expected " + this.bytesRemaining + " bytes but received " + j);
+            }
+            Http1Codec.this.sink.write(buffer, j);
+            this.bytesRemaining -= j;
+        }
+
+        @Override // com.mbridge.msdk.thrid.okio.Sink, java.io.Flushable
+        public void flush() throws IOException {
+            if (this.closed) {
+                return;
+            }
+            Http1Codec.this.sink.flush();
+        }
+
+        @Override // com.mbridge.msdk.thrid.okio.Sink, java.io.Closeable, java.lang.AutoCloseable
+        public void close() throws IOException {
+            if (this.closed) {
+                return;
+            }
+            this.closed = true;
+            if (this.bytesRemaining > 0) {
+                throw new ProtocolException("unexpected end of stream");
+            }
+            Http1Codec.this.detachTimeout(this.timeout);
+            Http1Codec.this.state = 3;
+        }
+    }
+
+    public final class ChunkedSink implements Sink {
+        private boolean closed;
+        private final ForwardingTimeout timeout;
+
+        @Override // com.mbridge.msdk.thrid.okio.Sink
+        public Timeout timeout() {
+            return this.timeout;
+        }
+
+        public ChunkedSink() {
+            this.timeout = new ForwardingTimeout(Http1Codec.this.sink.timeout());
+        }
+
+        @Override // com.mbridge.msdk.thrid.okio.Sink
+        public void write(Buffer buffer, long j) throws IOException {
+            if (this.closed) {
+                throw new IllegalStateException(Consts.PLACEMENT_STATUS_CLOSED);
+            }
+            if (j == 0) {
+                return;
+            }
+            Http1Codec.this.sink.writeHexadecimalUnsignedLong(j);
+            Http1Codec.this.sink.writeUtf8("\r\n");
+            Http1Codec.this.sink.write(buffer, j);
+            Http1Codec.this.sink.writeUtf8("\r\n");
+        }
+
+        @Override // com.mbridge.msdk.thrid.okio.Sink, java.io.Flushable
+        public synchronized void flush() throws IOException {
+            if (this.closed) {
+                return;
+            }
+            Http1Codec.this.sink.flush();
+        }
+
+        @Override // com.mbridge.msdk.thrid.okio.Sink, java.io.Closeable, java.lang.AutoCloseable
+        public synchronized void close() throws IOException {
+            if (this.closed) {
+                return;
+            }
+            this.closed = true;
+            Http1Codec.this.sink.writeUtf8("0\r\n\r\n");
+            Http1Codec.this.detachTimeout(this.timeout);
+            Http1Codec.this.state = 3;
+        }
+    }
+
+    public abstract class AbstractSource implements Source {
+        protected long bytesRead;
+        protected boolean closed;
+        protected final ForwardingTimeout timeout;
+
+        @Override // com.mbridge.msdk.thrid.okio.Source
+        public Timeout timeout() {
+            return this.timeout;
+        }
+
+        private AbstractSource() {
+            this.timeout = new ForwardingTimeout(Http1Codec.this.source.timeout());
+            this.bytesRead = 0L;
+        }
+
+        @Override // com.mbridge.msdk.thrid.okio.Source
+        public long read(Buffer buffer, long j) throws IOException {
+            try {
+                long read = Http1Codec.this.source.read(buffer, j);
+                if (read > 0) {
+                    this.bytesRead += read;
+                }
+                return read;
+            } catch (IOException e) {
+                endOfInput(false, e);
+                throw e;
+            }
+        }
+
+        public final void endOfInput(boolean z, IOException iOException) throws IOException {
+            Http1Codec http1Codec = Http1Codec.this;
+            int i = http1Codec.state;
+            if (i == 6) {
+                return;
+            }
+            if (i != 5) {
+                throw new IllegalStateException("state: " + Http1Codec.this.state);
+            }
+            http1Codec.detachTimeout(this.timeout);
+            Http1Codec http1Codec2 = Http1Codec.this;
+            http1Codec2.state = 6;
+            StreamAllocation streamAllocation = http1Codec2.streamAllocation;
+            if (streamAllocation != null) {
+                streamAllocation.streamFinished(!z, http1Codec2, this.bytesRead, iOException);
+            }
+        }
+    }
+
+    public class FixedLengthSource extends AbstractSource {
+        private long bytesRemaining;
+
+        public FixedLengthSource(long j) throws IOException {
+            super();
+            this.bytesRemaining = j;
+            if (j == 0) {
+                endOfInput(true, null);
+            }
+        }
+
+        @Override // com.mbridge.msdk.thrid.okhttp.internal.http1.Http1Codec.AbstractSource, com.mbridge.msdk.thrid.okio.Source
+        public long read(Buffer buffer, long j) throws IOException {
+            if (j < 0) {
+                throw new IllegalArgumentException("byteCount < 0: " + j);
+            }
+            if (this.closed) {
+                throw new IllegalStateException(Consts.PLACEMENT_STATUS_CLOSED);
+            }
+            long j2 = this.bytesRemaining;
+            if (j2 == 0) {
+                return -1L;
+            }
+            long read = super.read(buffer, Math.min(j2, j));
+            if (read == -1) {
+                ProtocolException protocolException = new ProtocolException("unexpected end of stream");
+                endOfInput(false, protocolException);
+                throw protocolException;
+            }
+            long j3 = this.bytesRemaining - read;
+            this.bytesRemaining = j3;
+            if (j3 == 0) {
+                endOfInput(true, null);
+            }
+            return read;
+        }
+
+        @Override // com.mbridge.msdk.thrid.okio.Source, java.io.Closeable, java.lang.AutoCloseable
+        public void close() throws IOException {
+            if (this.closed) {
+                return;
+            }
+            if (this.bytesRemaining != 0 && !Util.discard(this, 100, TimeUnit.MILLISECONDS)) {
+                endOfInput(false, null);
+            }
+            this.closed = true;
+        }
+    }
+
+    public class ChunkedSource extends AbstractSource {
+        private static final long NO_CHUNK_YET = -1;
+        private long bytesRemainingInChunk;
+        private boolean hasMoreChunks;
+        private final HttpUrl url;
+
+        public ChunkedSource(HttpUrl httpUrl) {
+            super();
+            this.bytesRemainingInChunk = -1L;
+            this.hasMoreChunks = true;
+            this.url = httpUrl;
+        }
+
+        @Override // com.mbridge.msdk.thrid.okhttp.internal.http1.Http1Codec.AbstractSource, com.mbridge.msdk.thrid.okio.Source
+        public long read(Buffer buffer, long j) throws IOException {
+            if (j < 0) {
+                throw new IllegalArgumentException("byteCount < 0: " + j);
+            }
+            if (this.closed) {
+                throw new IllegalStateException(Consts.PLACEMENT_STATUS_CLOSED);
+            }
+            if (!this.hasMoreChunks) {
+                return -1L;
+            }
+            long j2 = this.bytesRemainingInChunk;
+            if (j2 == 0 || j2 == -1) {
+                readChunkSize();
+                if (!this.hasMoreChunks) {
+                    return -1L;
+                }
+            }
+            long read = super.read(buffer, Math.min(j, this.bytesRemainingInChunk));
+            if (read != -1) {
+                this.bytesRemainingInChunk -= read;
+                return read;
+            }
+            ProtocolException protocolException = new ProtocolException("unexpected end of stream");
+            endOfInput(false, protocolException);
+            throw protocolException;
+        }
+
+        private void readChunkSize() throws IOException {
+            if (this.bytesRemainingInChunk != -1) {
+                Http1Codec.this.source.readUtf8LineStrict();
+            }
+            try {
+                this.bytesRemainingInChunk = Http1Codec.this.source.readHexadecimalUnsignedLong();
+                String trim = Http1Codec.this.source.readUtf8LineStrict().trim();
+                if (this.bytesRemainingInChunk < 0 || !(trim.isEmpty() || trim.startsWith(";"))) {
+                    throw new ProtocolException("expected chunk size and optional extensions but was \"" + this.bytesRemainingInChunk + trim + "\"");
+                }
+                if (this.bytesRemainingInChunk == 0) {
+                    this.hasMoreChunks = false;
+                    HttpHeaders.receiveHeaders(Http1Codec.this.client.cookieJar(), this.url, Http1Codec.this.readHeaders());
+                    endOfInput(true, null);
+                }
+            } catch (NumberFormatException e) {
+                throw new ProtocolException(e.getMessage());
+            }
+        }
+
+        @Override // com.mbridge.msdk.thrid.okio.Source, java.io.Closeable, java.lang.AutoCloseable
+        public void close() throws IOException {
+            if (this.closed) {
+                return;
+            }
+            if (this.hasMoreChunks && !Util.discard(this, 100, TimeUnit.MILLISECONDS)) {
+                endOfInput(false, null);
+            }
+            this.closed = true;
+        }
+    }
+
+    public class UnknownLengthSource extends AbstractSource {
+        private boolean inputExhausted;
+
+        public UnknownLengthSource() {
+            super();
+        }
+
+        @Override // com.mbridge.msdk.thrid.okhttp.internal.http1.Http1Codec.AbstractSource, com.mbridge.msdk.thrid.okio.Source
+        public long read(Buffer buffer, long j) throws IOException {
+            if (j < 0) {
+                throw new IllegalArgumentException("byteCount < 0: " + j);
+            }
+            if (this.closed) {
+                throw new IllegalStateException(Consts.PLACEMENT_STATUS_CLOSED);
+            }
+            if (this.inputExhausted) {
+                return -1L;
+            }
+            long read = super.read(buffer, j);
+            if (read != -1) {
+                return read;
+            }
+            this.inputExhausted = true;
+            endOfInput(true, null);
+            return -1L;
+        }
+
+        @Override // com.mbridge.msdk.thrid.okio.Source, java.io.Closeable, java.lang.AutoCloseable
+        public void close() throws IOException {
+            if (this.closed) {
+                return;
+            }
+            if (!this.inputExhausted) {
+                endOfInput(false, null);
+            }
+            this.closed = true;
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/thrid/okhttp/internal/http2/ConnectionShutdownException.java

@@ -0,0 +1,7 @@
+package com.mbridge.msdk.thrid.okhttp.internal.http2;
+
+import java.io.IOException;
+
+/* loaded from: classes4.dex */
+public final class ConnectionShutdownException extends IOException {
+}

decompiled/sources/com/mbridge/msdk/thrid/okhttp/internal/http2/ErrorCode.java

@@ -0,0 +1,31 @@
+package com.mbridge.msdk.thrid.okhttp.internal.http2;
+
+/* loaded from: classes4.dex */
+public enum ErrorCode {
+    NO_ERROR(0),
+    PROTOCOL_ERROR(1),
+    INTERNAL_ERROR(2),
+    FLOW_CONTROL_ERROR(3),
+    REFUSED_STREAM(7),
+    CANCEL(8),
+    COMPRESSION_ERROR(9),
+    CONNECT_ERROR(10),
+    ENHANCE_YOUR_CALM(11),
+    INADEQUATE_SECURITY(12),
+    HTTP_1_1_REQUIRED(13);
+
+    public final int httpCode;
+
+    ErrorCode(int i) {
+        this.httpCode = i;
+    }
+
+    public static ErrorCode fromHttp2(int i) {
+        for (ErrorCode errorCode : values()) {
+            if (errorCode.httpCode == i) {
+                return errorCode;
+            }
+        }
+        return null;
+    }
+}

decompiled/sources/com/mbridge/msdk/thrid/okhttp/internal/http2/Header.java

@@ -0,0 +1,59 @@
+package com.mbridge.msdk.thrid.okhttp.internal.http2;
+
+import com.facebook.internal.security.CertificateUtil;
+import com.ironsource.mediationsdk.logger.IronSourceError;
+import com.mbridge.msdk.thrid.okhttp.Headers;
+import com.mbridge.msdk.thrid.okhttp.internal.Util;
+import com.mbridge.msdk.thrid.okio.ByteString;
+
+/* loaded from: classes4.dex */
+public final class Header {
+    final int hpackSize;
+    public final ByteString name;
+    public final ByteString value;
+    public static final ByteString PSEUDO_PREFIX = ByteString.encodeUtf8(CertificateUtil.DELIMITER);
+    public static final String RESPONSE_STATUS_UTF8 = ":status";
+    public static final ByteString RESPONSE_STATUS = ByteString.encodeUtf8(RESPONSE_STATUS_UTF8);
+    public static final String TARGET_METHOD_UTF8 = ":method";
+    public static final ByteString TARGET_METHOD = ByteString.encodeUtf8(TARGET_METHOD_UTF8);
+    public static final String TARGET_PATH_UTF8 = ":path";
+    public static final ByteString TARGET_PATH = ByteString.encodeUtf8(TARGET_PATH_UTF8);
+    public static final String TARGET_SCHEME_UTF8 = ":scheme";
+    public static final ByteString TARGET_SCHEME = ByteString.encodeUtf8(TARGET_SCHEME_UTF8);
+    public static final String TARGET_AUTHORITY_UTF8 = ":authority";
+    public static final ByteString TARGET_AUTHORITY = ByteString.encodeUtf8(TARGET_AUTHORITY_UTF8);
+
+    public interface Listener {
+        void onHeaders(Headers headers);
+    }
+
+    public Header(String str, String str2) {
+        this(ByteString.encodeUtf8(str), ByteString.encodeUtf8(str2));
+    }
+
+    public Header(ByteString byteString, String str) {
+        this(byteString, ByteString.encodeUtf8(str));
+    }
+
+    public Header(ByteString byteString, ByteString byteString2) {
+        this.name = byteString;
+        this.value = byteString2;
+        this.hpackSize = byteString.size() + 32 + byteString2.size();
+    }
+
+    public boolean equals(Object obj) {
+        if (!(obj instanceof Header)) {
+            return false;
+        }
+        Header header = (Header) obj;
+        return this.name.equals(header.name) && this.value.equals(header.value);
+    }
+
+    public int hashCode() {
+        return ((IronSourceError.ERROR_NON_EXISTENT_INSTANCE + this.name.hashCode()) * 31) + this.value.hashCode();
+    }
+
+    public String toString() {
+        return Util.format("%s: %s", this.name.utf8(), this.value.utf8());
+    }
+}

decompiled/sources/com/mbridge/msdk/thrid/okhttp/internal/http2/Hpack.java

@@ -0,0 +1,512 @@
+package com.mbridge.msdk.thrid.okhttp.internal.http2;
+
+import com.ironsource.zk;
+import com.mbridge.msdk.foundation.download.database.DownloadModel;
+import com.mbridge.msdk.mbsignalcommon.commonwebview.ToolBar;
+import com.mbridge.msdk.thrid.okhttp.internal.Util;
+import com.mbridge.msdk.thrid.okio.Buffer;
+import com.mbridge.msdk.thrid.okio.BufferedSource;
+import com.mbridge.msdk.thrid.okio.ByteString;
+import com.mbridge.msdk.thrid.okio.Okio;
+import com.mbridge.msdk.thrid.okio.Source;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import kotlin.jvm.internal.ByteCompanionObject;
+import org.apache.http.cookie.ClientCookie;
+
+/* loaded from: classes4.dex */
+final class Hpack {
+    static final Map<ByteString, Integer> NAME_TO_FIRST_INDEX;
+    private static final int PREFIX_4_BITS = 15;
+    private static final int PREFIX_5_BITS = 31;
+    private static final int PREFIX_6_BITS = 63;
+    private static final int PREFIX_7_BITS = 127;
+    static final Header[] STATIC_HEADER_TABLE;
+
+    static {
+        Header header = new Header(Header.TARGET_AUTHORITY, "");
+        ByteString byteString = Header.TARGET_METHOD;
+        Header header2 = new Header(byteString, "GET");
+        Header header3 = new Header(byteString, "POST");
+        ByteString byteString2 = Header.TARGET_PATH;
+        Header header4 = new Header(byteString2, "/");
+        Header header5 = new Header(byteString2, "/index.html");
+        ByteString byteString3 = Header.TARGET_SCHEME;
+        Header header6 = new Header(byteString3, "http");
+        Header header7 = new Header(byteString3, "https");
+        ByteString byteString4 = Header.RESPONSE_STATUS;
+        STATIC_HEADER_TABLE = new Header[]{header, header2, header3, header4, header5, header6, header7, new Header(byteString4, "200"), new Header(byteString4, "204"), new Header(byteString4, "206"), new Header(byteString4, "304"), new Header(byteString4, "400"), new Header(byteString4, "404"), new Header(byteString4, "500"), new Header("accept-charset", ""), new Header("accept-encoding", "gzip, deflate"), new Header("accept-language", ""), new Header("accept-ranges", ""), new Header("accept", ""), new Header("access-control-allow-origin", ""), new Header("age", ""), new Header("allow", ""), new Header("authorization", ""), new Header("cache-control", ""), new Header("content-disposition", ""), new Header("content-encoding", ""), new Header("content-language", ""), new Header("content-length", ""), new Header("content-location", ""), new Header("content-range", ""), new Header("content-type", ""), new Header("cookie", ""), new Header("date", ""), new Header(DownloadModel.ETAG, ""), new Header("expect", ""), new Header(ClientCookie.EXPIRES_ATTR, ""), new Header("from", ""), new Header("host", ""), new Header("if-match", ""), new Header("if-modified-since", ""), new Header("if-none-match", ""), new Header("if-range", ""), new Header("if-unmodified-since", ""), new Header("last-modified", ""), new Header("link", ""), new Header("location", ""), new Header("max-forwards", ""), new Header("proxy-authenticate", ""), new Header("proxy-authorization", ""), new Header("range", ""), new Header("referer", ""), new Header(ToolBar.REFRESH, ""), new Header("retry-after", ""), new Header(zk.a, ""), new Header("set-cookie", ""), new Header("strict-transport-security", ""), new Header("transfer-encoding", ""), new Header("user-agent", ""), new Header("vary", ""), new Header("via", ""), new Header("www-authenticate", "")};
+        NAME_TO_FIRST_INDEX = nameToFirstIndex();
+    }
+
+    private Hpack() {
+    }
+
+    public static final class Reader {
+        Header[] dynamicTable;
+        int dynamicTableByteCount;
+        int headerCount;
+        private final List<Header> headerList;
+        private final int headerTableSizeSetting;
+        private int maxDynamicTableByteCount;
+        int nextHeaderIndex;
+        private final BufferedSource source;
+
+        private int dynamicTableIndex(int i) {
+            return this.nextHeaderIndex + 1 + i;
+        }
+
+        public int maxDynamicTableByteCount() {
+            return this.maxDynamicTableByteCount;
+        }
+
+        public Reader(int i, Source source) {
+            this(i, i, source);
+        }
+
+        public Reader(int i, int i2, Source source) {
+            this.headerList = new ArrayList();
+            this.dynamicTable = new Header[8];
+            this.nextHeaderIndex = r0.length - 1;
+            this.headerCount = 0;
+            this.dynamicTableByteCount = 0;
+            this.headerTableSizeSetting = i;
+            this.maxDynamicTableByteCount = i2;
+            this.source = Okio.buffer(source);
+        }
+
+        private void adjustDynamicTableByteCount() {
+            int i = this.maxDynamicTableByteCount;
+            int i2 = this.dynamicTableByteCount;
+            if (i < i2) {
+                if (i == 0) {
+                    clearDynamicTable();
+                } else {
+                    evictToRecoverBytes(i2 - i);
+                }
+            }
+        }
+
+        private void clearDynamicTable() {
+            Arrays.fill(this.dynamicTable, (Object) null);
+            this.nextHeaderIndex = this.dynamicTable.length - 1;
+            this.headerCount = 0;
+            this.dynamicTableByteCount = 0;
+        }
+
+        private int evictToRecoverBytes(int i) {
+            int i2;
+            int i3 = 0;
+            if (i > 0) {
+                int length = this.dynamicTable.length;
+                while (true) {
+                    length--;
+                    i2 = this.nextHeaderIndex;
+                    if (length < i2 || i <= 0) {
+                        break;
+                    }
+                    int i4 = this.dynamicTable[length].hpackSize;
+                    i -= i4;
+                    this.dynamicTableByteCount -= i4;
+                    this.headerCount--;
+                    i3++;
+                }
+                Header[] headerArr = this.dynamicTable;
+                System.arraycopy(headerArr, i2 + 1, headerArr, i2 + 1 + i3, this.headerCount);
+                this.nextHeaderIndex += i3;
+            }
+            return i3;
+        }
+
+        public void readHeaders() throws IOException {
+            while (!this.source.exhausted()) {
+                byte readByte = this.source.readByte();
+                int i = readByte & 255;
+                if (i == 128) {
+                    throw new IOException("index == 0");
+                }
+                if ((readByte & ByteCompanionObject.MIN_VALUE) == 128) {
+                    readIndexedHeader(readInt(i, 127) - 1);
+                } else if (i == 64) {
+                    readLiteralHeaderWithIncrementalIndexingNewName();
+                } else if ((readByte & 64) == 64) {
+                    readLiteralHeaderWithIncrementalIndexingIndexedName(readInt(i, 63) - 1);
+                } else if ((readByte & 32) == 32) {
+                    int readInt = readInt(i, 31);
+                    this.maxDynamicTableByteCount = readInt;
+                    if (readInt < 0 || readInt > this.headerTableSizeSetting) {
+                        throw new IOException("Invalid dynamic table size update " + this.maxDynamicTableByteCount);
+                    }
+                    adjustDynamicTableByteCount();
+                } else if (i == 16 || i == 0) {
+                    readLiteralHeaderWithoutIndexingNewName();
+                } else {
+                    readLiteralHeaderWithoutIndexingIndexedName(readInt(i, 15) - 1);
+                }
+            }
+        }
+
+        public List<Header> getAndResetHeaderList() {
+            ArrayList arrayList = new ArrayList(this.headerList);
+            this.headerList.clear();
+            return arrayList;
+        }
+
+        private void readIndexedHeader(int i) throws IOException {
+            if (isStaticHeader(i)) {
+                this.headerList.add(Hpack.STATIC_HEADER_TABLE[i]);
+                return;
+            }
+            int dynamicTableIndex = dynamicTableIndex(i - Hpack.STATIC_HEADER_TABLE.length);
+            if (dynamicTableIndex >= 0) {
+                Header[] headerArr = this.dynamicTable;
+                if (dynamicTableIndex < headerArr.length) {
+                    this.headerList.add(headerArr[dynamicTableIndex]);
+                    return;
+                }
+            }
+            throw new IOException("Header index too large " + (i + 1));
+        }
+
+        private void readLiteralHeaderWithoutIndexingIndexedName(int i) throws IOException {
+            this.headerList.add(new Header(getName(i), readByteString()));
+        }
+
+        private void readLiteralHeaderWithoutIndexingNewName() throws IOException {
+            this.headerList.add(new Header(Hpack.checkLowercase(readByteString()), readByteString()));
+        }
+
+        private void readLiteralHeaderWithIncrementalIndexingIndexedName(int i) throws IOException {
+            insertIntoDynamicTable(-1, new Header(getName(i), readByteString()));
+        }
+
+        private void readLiteralHeaderWithIncrementalIndexingNewName() throws IOException {
+            insertIntoDynamicTable(-1, new Header(Hpack.checkLowercase(readByteString()), readByteString()));
+        }
+
+        private ByteString getName(int i) throws IOException {
+            if (isStaticHeader(i)) {
+                return Hpack.STATIC_HEADER_TABLE[i].name;
+            }
+            int dynamicTableIndex = dynamicTableIndex(i - Hpack.STATIC_HEADER_TABLE.length);
+            if (dynamicTableIndex >= 0) {
+                Header[] headerArr = this.dynamicTable;
+                if (dynamicTableIndex < headerArr.length) {
+                    return headerArr[dynamicTableIndex].name;
+                }
+            }
+            throw new IOException("Header index too large " + (i + 1));
+        }
+
+        private boolean isStaticHeader(int i) {
+            return i >= 0 && i <= Hpack.STATIC_HEADER_TABLE.length - 1;
+        }
+
+        private void insertIntoDynamicTable(int i, Header header) {
+            this.headerList.add(header);
+            int i2 = header.hpackSize;
+            if (i != -1) {
+                i2 -= this.dynamicTable[dynamicTableIndex(i)].hpackSize;
+            }
+            int i3 = this.maxDynamicTableByteCount;
+            if (i2 > i3) {
+                clearDynamicTable();
+                return;
+            }
+            int evictToRecoverBytes = evictToRecoverBytes((this.dynamicTableByteCount + i2) - i3);
+            if (i == -1) {
+                int i4 = this.headerCount + 1;
+                Header[] headerArr = this.dynamicTable;
+                if (i4 > headerArr.length) {
+                    Header[] headerArr2 = new Header[headerArr.length * 2];
+                    System.arraycopy(headerArr, 0, headerArr2, headerArr.length, headerArr.length);
+                    this.nextHeaderIndex = this.dynamicTable.length - 1;
+                    this.dynamicTable = headerArr2;
+                }
+                int i5 = this.nextHeaderIndex;
+                this.nextHeaderIndex = i5 - 1;
+                this.dynamicTable[i5] = header;
+                this.headerCount++;
+            } else {
+                this.dynamicTable[i + dynamicTableIndex(i) + evictToRecoverBytes] = header;
+            }
+            this.dynamicTableByteCount += i2;
+        }
+
+        private int readByte() throws IOException {
+            return this.source.readByte() & 255;
+        }
+
+        public int readInt(int i, int i2) throws IOException {
+            int i3 = i & i2;
+            if (i3 < i2) {
+                return i3;
+            }
+            int i4 = 0;
+            while (true) {
+                int readByte = readByte();
+                if ((readByte & 128) == 0) {
+                    return i2 + (readByte << i4);
+                }
+                i2 += (readByte & 127) << i4;
+                i4 += 7;
+            }
+        }
+
+        public ByteString readByteString() throws IOException {
+            int readByte = readByte();
+            boolean z = (readByte & 128) == 128;
+            int readInt = readInt(readByte, 127);
+            if (z) {
+                return ByteString.of(Huffman.get().decode(this.source.readByteArray(readInt)));
+            }
+            return this.source.readByteString(readInt);
+        }
+    }
+
+    private static Map<ByteString, Integer> nameToFirstIndex() {
+        LinkedHashMap linkedHashMap = new LinkedHashMap(STATIC_HEADER_TABLE.length);
+        int i = 0;
+        while (true) {
+            Header[] headerArr = STATIC_HEADER_TABLE;
+            if (i < headerArr.length) {
+                if (!linkedHashMap.containsKey(headerArr[i].name)) {
+                    linkedHashMap.put(headerArr[i].name, Integer.valueOf(i));
+                }
+                i++;
+            } else {
+                return Collections.unmodifiableMap(linkedHashMap);
+            }
+        }
+    }
+
+    public static final class Writer {
+        private static final int SETTINGS_HEADER_TABLE_SIZE = 4096;
+        private static final int SETTINGS_HEADER_TABLE_SIZE_LIMIT = 16384;
+        Header[] dynamicTable;
+        int dynamicTableByteCount;
+        private boolean emitDynamicTableSizeUpdate;
+        int headerCount;
+        int headerTableSizeSetting;
+        int maxDynamicTableByteCount;
+        int nextHeaderIndex;
+        private final Buffer out;
+        private int smallestHeaderTableSizeSetting;
+        private final boolean useCompression;
+
+        public Writer(Buffer buffer) {
+            this(4096, true, buffer);
+        }
+
+        public Writer(int i, boolean z, Buffer buffer) {
+            this.smallestHeaderTableSizeSetting = Integer.MAX_VALUE;
+            this.dynamicTable = new Header[8];
+            this.nextHeaderIndex = r0.length - 1;
+            this.headerCount = 0;
+            this.dynamicTableByteCount = 0;
+            this.headerTableSizeSetting = i;
+            this.maxDynamicTableByteCount = i;
+            this.useCompression = z;
+            this.out = buffer;
+        }
+
+        private void clearDynamicTable() {
+            Arrays.fill(this.dynamicTable, (Object) null);
+            this.nextHeaderIndex = this.dynamicTable.length - 1;
+            this.headerCount = 0;
+            this.dynamicTableByteCount = 0;
+        }
+
+        private int evictToRecoverBytes(int i) {
+            int i2;
+            int i3 = 0;
+            if (i > 0) {
+                int length = this.dynamicTable.length;
+                while (true) {
+                    length--;
+                    i2 = this.nextHeaderIndex;
+                    if (length < i2 || i <= 0) {
+                        break;
+                    }
+                    int i4 = this.dynamicTable[length].hpackSize;
+                    i -= i4;
+                    this.dynamicTableByteCount -= i4;
+                    this.headerCount--;
+                    i3++;
+                }
+                Header[] headerArr = this.dynamicTable;
+                System.arraycopy(headerArr, i2 + 1, headerArr, i2 + 1 + i3, this.headerCount);
+                Header[] headerArr2 = this.dynamicTable;
+                int i5 = this.nextHeaderIndex;
+                Arrays.fill(headerArr2, i5 + 1, i5 + 1 + i3, (Object) null);
+                this.nextHeaderIndex += i3;
+            }
+            return i3;
+        }
+
+        private void insertIntoDynamicTable(Header header) {
+            int i = header.hpackSize;
+            int i2 = this.maxDynamicTableByteCount;
+            if (i > i2) {
+                clearDynamicTable();
+                return;
+            }
+            evictToRecoverBytes((this.dynamicTableByteCount + i) - i2);
+            int i3 = this.headerCount + 1;
+            Header[] headerArr = this.dynamicTable;
+            if (i3 > headerArr.length) {
+                Header[] headerArr2 = new Header[headerArr.length * 2];
+                System.arraycopy(headerArr, 0, headerArr2, headerArr.length, headerArr.length);
+                this.nextHeaderIndex = this.dynamicTable.length - 1;
+                this.dynamicTable = headerArr2;
+            }
+            int i4 = this.nextHeaderIndex;
+            this.nextHeaderIndex = i4 - 1;
+            this.dynamicTable[i4] = header;
+            this.headerCount++;
+            this.dynamicTableByteCount += i;
+        }
+
+        public void writeHeaders(List<Header> list) throws IOException {
+            int i;
+            int i2;
+            if (this.emitDynamicTableSizeUpdate) {
+                int i3 = this.smallestHeaderTableSizeSetting;
+                if (i3 < this.maxDynamicTableByteCount) {
+                    writeInt(i3, 31, 32);
+                }
+                this.emitDynamicTableSizeUpdate = false;
+                this.smallestHeaderTableSizeSetting = Integer.MAX_VALUE;
+                writeInt(this.maxDynamicTableByteCount, 31, 32);
+            }
+            int size = list.size();
+            for (int i4 = 0; i4 < size; i4++) {
+                Header header = list.get(i4);
+                ByteString asciiLowercase = header.name.toAsciiLowercase();
+                ByteString byteString = header.value;
+                Integer num = Hpack.NAME_TO_FIRST_INDEX.get(asciiLowercase);
+                if (num != null) {
+                    int intValue = num.intValue();
+                    i2 = intValue + 1;
+                    if (i2 > 1 && i2 < 8) {
+                        Header[] headerArr = Hpack.STATIC_HEADER_TABLE;
+                        if (Util.equal(headerArr[intValue].value, byteString)) {
+                            i = i2;
+                        } else if (Util.equal(headerArr[i2].value, byteString)) {
+                            i2 = intValue + 2;
+                            i = i2;
+                        }
+                    }
+                    i = i2;
+                    i2 = -1;
+                } else {
+                    i = -1;
+                    i2 = -1;
+                }
+                if (i2 == -1) {
+                    int i5 = this.nextHeaderIndex + 1;
+                    int length = this.dynamicTable.length;
+                    while (true) {
+                        if (i5 >= length) {
+                            break;
+                        }
+                        if (Util.equal(this.dynamicTable[i5].name, asciiLowercase)) {
+                            if (Util.equal(this.dynamicTable[i5].value, byteString)) {
+                                i2 = (i5 - this.nextHeaderIndex) + Hpack.STATIC_HEADER_TABLE.length;
+                                break;
+                            } else if (i == -1) {
+                                i = (i5 - this.nextHeaderIndex) + Hpack.STATIC_HEADER_TABLE.length;
+                            }
+                        }
+                        i5++;
+                    }
+                }
+                if (i2 != -1) {
+                    writeInt(i2, 127, 128);
+                } else if (i == -1) {
+                    this.out.writeByte(64);
+                    writeByteString(asciiLowercase);
+                    writeByteString(byteString);
+                    insertIntoDynamicTable(header);
+                } else if (asciiLowercase.startsWith(Header.PSEUDO_PREFIX) && !Header.TARGET_AUTHORITY.equals(asciiLowercase)) {
+                    writeInt(i, 15, 0);
+                    writeByteString(byteString);
+                } else {
+                    writeInt(i, 63, 64);
+                    writeByteString(byteString);
+                    insertIntoDynamicTable(header);
+                }
+            }
+        }
+
+        public void writeInt(int i, int i2, int i3) {
+            if (i < i2) {
+                this.out.writeByte(i | i3);
+                return;
+            }
+            this.out.writeByte(i3 | i2);
+            int i4 = i - i2;
+            while (i4 >= 128) {
+                this.out.writeByte(128 | (i4 & 127));
+                i4 >>>= 7;
+            }
+            this.out.writeByte(i4);
+        }
+
+        public void writeByteString(ByteString byteString) throws IOException {
+            if (this.useCompression && Huffman.get().encodedLength(byteString) < byteString.size()) {
+                Buffer buffer = new Buffer();
+                Huffman.get().encode(byteString, buffer);
+                ByteString readByteString = buffer.readByteString();
+                writeInt(readByteString.size(), 127, 128);
+                this.out.write(readByteString);
+                return;
+            }
+            writeInt(byteString.size(), 127, 0);
+            this.out.write(byteString);
+        }
+
+        public void setHeaderTableSizeSetting(int i) {
+            this.headerTableSizeSetting = i;
+            int min = Math.min(i, 16384);
+            int i2 = this.maxDynamicTableByteCount;
+            if (i2 == min) {
+                return;
+            }
+            if (min < i2) {
+                this.smallestHeaderTableSizeSetting = Math.min(this.smallestHeaderTableSizeSetting, min);
+            }
+            this.emitDynamicTableSizeUpdate = true;
+            this.maxDynamicTableByteCount = min;
+            adjustDynamicTableByteCount();
+        }
+
+        private void adjustDynamicTableByteCount() {
+            int i = this.maxDynamicTableByteCount;
+            int i2 = this.dynamicTableByteCount;
+            if (i < i2) {
+                if (i == 0) {
+                    clearDynamicTable();
+                } else {
+                    evictToRecoverBytes(i2 - i);
+                }
+            }
+        }
+    }
+
+    public static ByteString checkLowercase(ByteString byteString) throws IOException {
+        int size = byteString.size();
+        for (int i = 0; i < size; i++) {
+            byte b = byteString.getByte(i);
+            if (b >= 65 && b <= 90) {
+                throw new IOException("PROTOCOL_ERROR response malformed: mixed case name: " + byteString.utf8());
+            }
+        }
+        return byteString;
+    }
+}

decompiled/sources/com/mbridge/msdk/thrid/okhttp/internal/http2/Http2.java

@@ -0,0 +1,118 @@
+package com.mbridge.msdk.thrid.okhttp.internal.http2;
+
+import com.mbridge.msdk.thrid.okhttp.internal.Util;
+import com.mbridge.msdk.thrid.okio.ByteString;
+import java.io.IOException;
+
+/* loaded from: classes4.dex */
+public final class Http2 {
+    static final byte FLAG_ACK = 1;
+    static final byte FLAG_COMPRESSED = 32;
+    static final byte FLAG_END_HEADERS = 4;
+    static final byte FLAG_END_PUSH_PROMISE = 4;
+    static final byte FLAG_END_STREAM = 1;
+    static final byte FLAG_NONE = 0;
+    static final byte FLAG_PADDED = 8;
+    static final byte FLAG_PRIORITY = 32;
+    static final int INITIAL_MAX_FRAME_SIZE = 16384;
+    static final byte TYPE_CONTINUATION = 9;
+    static final byte TYPE_DATA = 0;
+    static final byte TYPE_GOAWAY = 7;
+    static final byte TYPE_HEADERS = 1;
+    static final byte TYPE_PING = 6;
+    static final byte TYPE_PRIORITY = 2;
+    static final byte TYPE_PUSH_PROMISE = 5;
+    static final byte TYPE_RST_STREAM = 3;
+    static final byte TYPE_SETTINGS = 4;
+    static final byte TYPE_WINDOW_UPDATE = 8;
+    static final ByteString CONNECTION_PREFACE = ByteString.encodeUtf8("PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n");
+    private static final String[] FRAME_NAMES = {"DATA", "HEADERS", "PRIORITY", "RST_STREAM", "SETTINGS", "PUSH_PROMISE", "PING", "GOAWAY", "WINDOW_UPDATE", "CONTINUATION"};
+    static final String[] FLAGS = new String[64];
+    static final String[] BINARY = new String[256];
+
+    static {
+        int i = 0;
+        int i2 = 0;
+        while (true) {
+            String[] strArr = BINARY;
+            if (i2 >= strArr.length) {
+                break;
+            }
+            strArr[i2] = Util.format("%8s", Integer.toBinaryString(i2)).replace(' ', '0');
+            i2++;
+        }
+        String[] strArr2 = FLAGS;
+        strArr2[0] = "";
+        strArr2[1] = "END_STREAM";
+        int[] iArr = {1};
+        strArr2[8] = "PADDED";
+        int i3 = iArr[0];
+        strArr2[i3 | 8] = strArr2[i3] + "|PADDED";
+        strArr2[4] = "END_HEADERS";
+        strArr2[32] = "PRIORITY";
+        strArr2[36] = "END_HEADERS|PRIORITY";
+        int[] iArr2 = {4, 32, 36};
+        for (int i4 = 0; i4 < 3; i4++) {
+            int i5 = iArr2[i4];
+            int i6 = iArr[0];
+            String[] strArr3 = FLAGS;
+            int i7 = i6 | i5;
+            strArr3[i7] = strArr3[i6] + '|' + strArr3[i5];
+            strArr3[i7 | 8] = strArr3[i6] + '|' + strArr3[i5] + "|PADDED";
+        }
+        while (true) {
+            String[] strArr4 = FLAGS;
+            if (i >= strArr4.length) {
+                return;
+            }
+            if (strArr4[i] == null) {
+                strArr4[i] = BINARY[i];
+            }
+            i++;
+        }
+    }
+
+    private Http2() {
+    }
+
+    public static IllegalArgumentException illegalArgument(String str, Object... objArr) {
+        throw new IllegalArgumentException(Util.format(str, objArr));
+    }
+
+    public static IOException ioException(String str, Object... objArr) throws IOException {
+        throw new IOException(Util.format(str, objArr));
+    }
+
+    public static String frameLog(boolean z, int i, int i2, byte b, byte b2) {
+        String[] strArr = FRAME_NAMES;
+        String format = b < strArr.length ? strArr[b] : Util.format("0x%02x", Byte.valueOf(b));
+        String formatFlags = formatFlags(b, b2);
+        Object[] objArr = new Object[5];
+        objArr[0] = z ? "<<" : ">>";
+        objArr[1] = Integer.valueOf(i);
+        objArr[2] = Integer.valueOf(i2);
+        objArr[3] = format;
+        objArr[4] = formatFlags;
+        return Util.format("%s 0x%08x %5d %-13s %s", objArr);
+    }
+
+    public static String formatFlags(byte b, byte b2) {
+        if (b2 == 0) {
+            return "";
+        }
+        if (b != 2 && b != 3) {
+            if (b == 4 || b == 6) {
+                return b2 == 1 ? "ACK" : BINARY[b2];
+            }
+            if (b != 7 && b != 8) {
+                String[] strArr = FLAGS;
+                String str = b2 < strArr.length ? strArr[b2] : BINARY[b2];
+                if (b != 5 || (b2 & 4) == 0) {
+                    return (b != 0 || (b2 & 32) == 0) ? str : str.replace("PRIORITY", "COMPRESSED");
+                }
+                return str.replace("HEADERS", "PUSH_PROMISE");
+            }
+        }
+        return BINARY[b2];
+    }
+}

decompiled/sources/com/mbridge/msdk/thrid/okhttp/internal/http2/Http2Codec.java

@@ -0,0 +1,191 @@
+package com.mbridge.msdk.thrid.okhttp.internal.http2;
+
+import com.mbridge.msdk.thrid.okhttp.Headers;
+import com.mbridge.msdk.thrid.okhttp.Interceptor;
+import com.mbridge.msdk.thrid.okhttp.OkHttpClient;
+import com.mbridge.msdk.thrid.okhttp.Protocol;
+import com.mbridge.msdk.thrid.okhttp.Request;
+import com.mbridge.msdk.thrid.okhttp.Response;
+import com.mbridge.msdk.thrid.okhttp.ResponseBody;
+import com.mbridge.msdk.thrid.okhttp.internal.Internal;
+import com.mbridge.msdk.thrid.okhttp.internal.Util;
+import com.mbridge.msdk.thrid.okhttp.internal.connection.StreamAllocation;
+import com.mbridge.msdk.thrid.okhttp.internal.http.HttpCodec;
+import com.mbridge.msdk.thrid.okhttp.internal.http.HttpHeaders;
+import com.mbridge.msdk.thrid.okhttp.internal.http.RealResponseBody;
+import com.mbridge.msdk.thrid.okhttp.internal.http.RequestLine;
+import com.mbridge.msdk.thrid.okhttp.internal.http.StatusLine;
+import com.mbridge.msdk.thrid.okio.Buffer;
+import com.mbridge.msdk.thrid.okio.ByteString;
+import com.mbridge.msdk.thrid.okio.ForwardingSource;
+import com.mbridge.msdk.thrid.okio.Okio;
+import com.mbridge.msdk.thrid.okio.Sink;
+import com.mbridge.msdk.thrid.okio.Source;
+import com.mbridge.msdk.thrid.okio.Timeout;
+import java.io.IOException;
+import java.net.ProtocolException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Locale;
+import java.util.concurrent.TimeUnit;
+import org.apache.http.protocol.HTTP;
+
+/* loaded from: classes4.dex */
+public final class Http2Codec implements HttpCodec {
+    private final Interceptor.Chain chain;
+    private final Http2Connection connection;
+    private final Protocol protocol;
+    private Http2Stream stream;
+    final StreamAllocation streamAllocation;
+    private static final String CONNECTION = "connection";
+    private static final String HOST = "host";
+    private static final String KEEP_ALIVE = "keep-alive";
+    private static final String PROXY_CONNECTION = "proxy-connection";
+    private static final String TE = "te";
+    private static final String TRANSFER_ENCODING = "transfer-encoding";
+    private static final String ENCODING = "encoding";
+    private static final String UPGRADE = "upgrade";
+    private static final List<String> HTTP_2_SKIPPED_REQUEST_HEADERS = Util.immutableList(CONNECTION, HOST, KEEP_ALIVE, PROXY_CONNECTION, TE, TRANSFER_ENCODING, ENCODING, UPGRADE, Header.TARGET_METHOD_UTF8, Header.TARGET_PATH_UTF8, Header.TARGET_SCHEME_UTF8, Header.TARGET_AUTHORITY_UTF8);
+    private static final List<String> HTTP_2_SKIPPED_RESPONSE_HEADERS = Util.immutableList(CONNECTION, HOST, KEEP_ALIVE, PROXY_CONNECTION, TE, TRANSFER_ENCODING, ENCODING, UPGRADE);
+
+    public Http2Codec(OkHttpClient okHttpClient, Interceptor.Chain chain, StreamAllocation streamAllocation, Http2Connection http2Connection) {
+        this.chain = chain;
+        this.streamAllocation = streamAllocation;
+        this.connection = http2Connection;
+        List<Protocol> protocols = okHttpClient.protocols();
+        Protocol protocol = Protocol.H2_PRIOR_KNOWLEDGE;
+        this.protocol = protocols.contains(protocol) ? protocol : Protocol.HTTP_2;
+    }
+
+    @Override // com.mbridge.msdk.thrid.okhttp.internal.http.HttpCodec
+    public Sink createRequestBody(Request request, long j) {
+        return this.stream.getSink();
+    }
+
+    @Override // com.mbridge.msdk.thrid.okhttp.internal.http.HttpCodec
+    public void writeRequestHeaders(Request request) throws IOException {
+        if (this.stream != null) {
+            return;
+        }
+        Http2Stream newStream = this.connection.newStream(http2HeadersList(request), request.body() != null);
+        this.stream = newStream;
+        Timeout readTimeout = newStream.readTimeout();
+        long readTimeoutMillis = this.chain.readTimeoutMillis();
+        TimeUnit timeUnit = TimeUnit.MILLISECONDS;
+        readTimeout.timeout(readTimeoutMillis, timeUnit);
+        this.stream.writeTimeout().timeout(this.chain.writeTimeoutMillis(), timeUnit);
+    }
+
+    @Override // com.mbridge.msdk.thrid.okhttp.internal.http.HttpCodec
+    public void flushRequest() throws IOException {
+        this.connection.flush();
+    }
+
+    @Override // com.mbridge.msdk.thrid.okhttp.internal.http.HttpCodec
+    public void finishRequest() throws IOException {
+        this.stream.getSink().close();
+    }
+
+    @Override // com.mbridge.msdk.thrid.okhttp.internal.http.HttpCodec
+    public Response.Builder readResponseHeaders(boolean z) throws IOException {
+        Response.Builder readHttp2HeadersList = readHttp2HeadersList(this.stream.takeHeaders(), this.protocol);
+        if (z && Internal.instance.code(readHttp2HeadersList) == 100) {
+            return null;
+        }
+        return readHttp2HeadersList;
+    }
+
+    public static List<Header> http2HeadersList(Request request) {
+        Headers headers = request.headers();
+        ArrayList arrayList = new ArrayList(headers.size() + 4);
+        arrayList.add(new Header(Header.TARGET_METHOD, request.method()));
+        arrayList.add(new Header(Header.TARGET_PATH, RequestLine.requestPath(request.url())));
+        String header = request.header(HTTP.TARGET_HOST);
+        if (header != null) {
+            arrayList.add(new Header(Header.TARGET_AUTHORITY, header));
+        }
+        arrayList.add(new Header(Header.TARGET_SCHEME, request.url().scheme()));
+        int size = headers.size();
+        for (int i = 0; i < size; i++) {
+            ByteString encodeUtf8 = ByteString.encodeUtf8(headers.name(i).toLowerCase(Locale.US));
+            if (!HTTP_2_SKIPPED_REQUEST_HEADERS.contains(encodeUtf8.utf8())) {
+                arrayList.add(new Header(encodeUtf8, headers.value(i)));
+            }
+        }
+        return arrayList;
+    }
+
+    public static Response.Builder readHttp2HeadersList(Headers headers, Protocol protocol) throws IOException {
+        Headers.Builder builder = new Headers.Builder();
+        int size = headers.size();
+        StatusLine statusLine = null;
+        for (int i = 0; i < size; i++) {
+            String name = headers.name(i);
+            String value = headers.value(i);
+            if (name.equals(Header.RESPONSE_STATUS_UTF8)) {
+                statusLine = StatusLine.parse("HTTP/1.1 " + value);
+            } else if (!HTTP_2_SKIPPED_RESPONSE_HEADERS.contains(name)) {
+                Internal.instance.addLenient(builder, name, value);
+            }
+        }
+        if (statusLine == null) {
+            throw new ProtocolException("Expected ':status' header not present");
+        }
+        return new Response.Builder().protocol(protocol).code(statusLine.code).message(statusLine.message).headers(builder.build());
+    }
+
+    @Override // com.mbridge.msdk.thrid.okhttp.internal.http.HttpCodec
+    public ResponseBody openResponseBody(Response response) throws IOException {
+        StreamAllocation streamAllocation = this.streamAllocation;
+        streamAllocation.eventListener.responseBodyStart(streamAllocation.call);
+        return new RealResponseBody(response.header("Content-Type"), HttpHeaders.contentLength(response), Okio.buffer(new StreamFinishingSource(this.stream.getSource())));
+    }
+
+    @Override // com.mbridge.msdk.thrid.okhttp.internal.http.HttpCodec
+    public void cancel() {
+        Http2Stream http2Stream = this.stream;
+        if (http2Stream != null) {
+            http2Stream.closeLater(ErrorCode.CANCEL);
+        }
+    }
+
+    public class StreamFinishingSource extends ForwardingSource {
+        long bytesRead;
+        boolean completed;
+
+        public StreamFinishingSource(Source source) {
+            super(source);
+            this.completed = false;
+            this.bytesRead = 0L;
+        }
+
+        @Override // com.mbridge.msdk.thrid.okio.ForwardingSource, com.mbridge.msdk.thrid.okio.Source
+        public long read(Buffer buffer, long j) throws IOException {
+            try {
+                long read = delegate().read(buffer, j);
+                if (read > 0) {
+                    this.bytesRead += read;
+                }
+                return read;
+            } catch (IOException e) {
+                endOfInput(e);
+                throw e;
+            }
+        }
+
+        @Override // com.mbridge.msdk.thrid.okio.ForwardingSource, com.mbridge.msdk.thrid.okio.Source, java.io.Closeable, java.lang.AutoCloseable
+        public void close() throws IOException {
+            super.close();
+            endOfInput(null);
+        }
+
+        private void endOfInput(IOException iOException) {
+            if (this.completed) {
+                return;
+            }
+            this.completed = true;
+            Http2Codec http2Codec = Http2Codec.this;
+            http2Codec.streamAllocation.streamFinished(false, http2Codec, this.bytesRead, iOException);
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/thrid/okhttp/internal/http2/Http2Reader.java

@@ -0,0 +1,366 @@
+package com.mbridge.msdk.thrid.okhttp.internal.http2;
+
+import com.mbridge.msdk.thrid.okhttp.internal.Util;
+import com.mbridge.msdk.thrid.okhttp.internal.http2.Hpack;
+import com.mbridge.msdk.thrid.okio.Buffer;
+import com.mbridge.msdk.thrid.okio.BufferedSource;
+import com.mbridge.msdk.thrid.okio.ByteString;
+import com.mbridge.msdk.thrid.okio.Source;
+import com.mbridge.msdk.thrid.okio.Timeout;
+import java.io.Closeable;
+import java.io.IOException;
+import java.util.List;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+/* loaded from: classes4.dex */
+final class Http2Reader implements Closeable {
+    static final Logger logger = Logger.getLogger(Http2.class.getName());
+    private final boolean client;
+    private final ContinuationSource continuation;
+    final Hpack.Reader hpackReader;
+    private final BufferedSource source;
+
+    public interface Handler {
+        void ackSettings();
+
+        void alternateService(int i, String str, ByteString byteString, String str2, int i2, long j);
+
+        void data(boolean z, int i, BufferedSource bufferedSource, int i2) throws IOException;
+
+        void goAway(int i, ErrorCode errorCode, ByteString byteString);
+
+        void headers(boolean z, int i, int i2, List<Header> list);
+
+        void ping(boolean z, int i, int i2);
+
+        void priority(int i, int i2, int i3, boolean z);
+
+        void pushPromise(int i, int i2, List<Header> list) throws IOException;
+
+        void rstStream(int i, ErrorCode errorCode);
+
+        void settings(boolean z, Settings settings);
+
+        void windowUpdate(int i, long j);
+    }
+
+    public Http2Reader(BufferedSource bufferedSource, boolean z) {
+        this.source = bufferedSource;
+        this.client = z;
+        ContinuationSource continuationSource = new ContinuationSource(bufferedSource);
+        this.continuation = continuationSource;
+        this.hpackReader = new Hpack.Reader(4096, continuationSource);
+    }
+
+    public void readConnectionPreface(Handler handler) throws IOException {
+        if (this.client) {
+            if (!nextFrame(true, handler)) {
+                throw Http2.ioException("Required SETTINGS preface not received", new Object[0]);
+            }
+            return;
+        }
+        BufferedSource bufferedSource = this.source;
+        ByteString byteString = Http2.CONNECTION_PREFACE;
+        ByteString readByteString = bufferedSource.readByteString(byteString.size());
+        Logger logger2 = logger;
+        if (logger2.isLoggable(Level.FINE)) {
+            logger2.fine(Util.format("<< CONNECTION %s", readByteString.hex()));
+        }
+        if (!byteString.equals(readByteString)) {
+            throw Http2.ioException("Expected a connection header but was %s", readByteString.utf8());
+        }
+    }
+
+    public boolean nextFrame(boolean z, Handler handler) throws IOException {
+        try {
+            this.source.require(9L);
+            int readMedium = readMedium(this.source);
+            if (readMedium < 0 || readMedium > 16384) {
+                throw Http2.ioException("FRAME_SIZE_ERROR: %s", Integer.valueOf(readMedium));
+            }
+            byte readByte = (byte) (this.source.readByte() & 255);
+            if (z && readByte != 4) {
+                throw Http2.ioException("Expected a SETTINGS frame but was %s", Byte.valueOf(readByte));
+            }
+            byte readByte2 = (byte) (this.source.readByte() & 255);
+            int readInt = this.source.readInt() & Integer.MAX_VALUE;
+            Logger logger2 = logger;
+            if (logger2.isLoggable(Level.FINE)) {
+                logger2.fine(Http2.frameLog(true, readInt, readMedium, readByte, readByte2));
+            }
+            switch (readByte) {
+                case 0:
+                    readData(handler, readMedium, readByte2, readInt);
+                    return true;
+                case 1:
+                    readHeaders(handler, readMedium, readByte2, readInt);
+                    return true;
+                case 2:
+                    readPriority(handler, readMedium, readByte2, readInt);
+                    return true;
+                case 3:
+                    readRstStream(handler, readMedium, readByte2, readInt);
+                    return true;
+                case 4:
+                    readSettings(handler, readMedium, readByte2, readInt);
+                    return true;
+                case 5:
+                    readPushPromise(handler, readMedium, readByte2, readInt);
+                    return true;
+                case 6:
+                    readPing(handler, readMedium, readByte2, readInt);
+                    return true;
+                case 7:
+                    readGoAway(handler, readMedium, readByte2, readInt);
+                    return true;
+                case 8:
+                    readWindowUpdate(handler, readMedium, readByte2, readInt);
+                    return true;
+                default:
+                    this.source.skip(readMedium);
+                    return true;
+            }
+        } catch (IOException unused) {
+            return false;
+        }
+    }
+
+    private void readHeaders(Handler handler, int i, byte b, int i2) throws IOException {
+        if (i2 == 0) {
+            throw Http2.ioException("PROTOCOL_ERROR: TYPE_HEADERS streamId == 0", new Object[0]);
+        }
+        boolean z = (b & 1) != 0;
+        short readByte = (b & 8) != 0 ? (short) (this.source.readByte() & 255) : (short) 0;
+        if ((b & 32) != 0) {
+            readPriority(handler, i2);
+            i -= 5;
+        }
+        handler.headers(z, i2, -1, readHeaderBlock(lengthWithoutPadding(i, b, readByte), readByte, b, i2));
+    }
+
+    private List<Header> readHeaderBlock(int i, short s, byte b, int i2) throws IOException {
+        ContinuationSource continuationSource = this.continuation;
+        continuationSource.left = i;
+        continuationSource.length = i;
+        continuationSource.padding = s;
+        continuationSource.flags = b;
+        continuationSource.streamId = i2;
+        this.hpackReader.readHeaders();
+        return this.hpackReader.getAndResetHeaderList();
+    }
+
+    private void readData(Handler handler, int i, byte b, int i2) throws IOException {
+        if (i2 == 0) {
+            throw Http2.ioException("PROTOCOL_ERROR: TYPE_DATA streamId == 0", new Object[0]);
+        }
+        boolean z = (b & 1) != 0;
+        if ((b & 32) != 0) {
+            throw Http2.ioException("PROTOCOL_ERROR: FLAG_COMPRESSED without SETTINGS_COMPRESS_DATA", new Object[0]);
+        }
+        short readByte = (b & 8) != 0 ? (short) (this.source.readByte() & 255) : (short) 0;
+        handler.data(z, i2, this.source, lengthWithoutPadding(i, b, readByte));
+        this.source.skip(readByte);
+    }
+
+    private void readPriority(Handler handler, int i, byte b, int i2) throws IOException {
+        if (i != 5) {
+            throw Http2.ioException("TYPE_PRIORITY length: %d != 5", Integer.valueOf(i));
+        }
+        if (i2 == 0) {
+            throw Http2.ioException("TYPE_PRIORITY streamId == 0", new Object[0]);
+        }
+        readPriority(handler, i2);
+    }
+
+    private void readPriority(Handler handler, int i) throws IOException {
+        int readInt = this.source.readInt();
+        handler.priority(i, readInt & Integer.MAX_VALUE, (this.source.readByte() & 255) + 1, (Integer.MIN_VALUE & readInt) != 0);
+    }
+
+    private void readRstStream(Handler handler, int i, byte b, int i2) throws IOException {
+        if (i != 4) {
+            throw Http2.ioException("TYPE_RST_STREAM length: %d != 4", Integer.valueOf(i));
+        }
+        if (i2 == 0) {
+            throw Http2.ioException("TYPE_RST_STREAM streamId == 0", new Object[0]);
+        }
+        int readInt = this.source.readInt();
+        ErrorCode fromHttp2 = ErrorCode.fromHttp2(readInt);
+        if (fromHttp2 == null) {
+            throw Http2.ioException("TYPE_RST_STREAM unexpected error code: %d", Integer.valueOf(readInt));
+        }
+        handler.rstStream(i2, fromHttp2);
+    }
+
+    private void readSettings(Handler handler, int i, byte b, int i2) throws IOException {
+        if (i2 != 0) {
+            throw Http2.ioException("TYPE_SETTINGS streamId != 0", new Object[0]);
+        }
+        if ((b & 1) != 0) {
+            if (i != 0) {
+                throw Http2.ioException("FRAME_SIZE_ERROR ack frame should be empty!", new Object[0]);
+            }
+            handler.ackSettings();
+            return;
+        }
+        if (i % 6 != 0) {
+            throw Http2.ioException("TYPE_SETTINGS length %% 6 != 0: %s", Integer.valueOf(i));
+        }
+        Settings settings = new Settings();
+        for (int i3 = 0; i3 < i; i3 += 6) {
+            int readShort = this.source.readShort() & 65535;
+            int readInt = this.source.readInt();
+            if (readShort != 2) {
+                if (readShort == 3) {
+                    readShort = 4;
+                } else if (readShort == 4) {
+                    if (readInt < 0) {
+                        throw Http2.ioException("PROTOCOL_ERROR SETTINGS_INITIAL_WINDOW_SIZE > 2^31 - 1", new Object[0]);
+                    }
+                    readShort = 7;
+                } else if (readShort == 5 && (readInt < 16384 || readInt > 16777215)) {
+                    throw Http2.ioException("PROTOCOL_ERROR SETTINGS_MAX_FRAME_SIZE: %s", Integer.valueOf(readInt));
+                }
+            } else if (readInt != 0 && readInt != 1) {
+                throw Http2.ioException("PROTOCOL_ERROR SETTINGS_ENABLE_PUSH != 0 or 1", new Object[0]);
+            }
+            settings.set(readShort, readInt);
+        }
+        handler.settings(false, settings);
+    }
+
+    private void readPushPromise(Handler handler, int i, byte b, int i2) throws IOException {
+        if (i2 == 0) {
+            throw Http2.ioException("PROTOCOL_ERROR: TYPE_PUSH_PROMISE streamId == 0", new Object[0]);
+        }
+        short readByte = (b & 8) != 0 ? (short) (this.source.readByte() & 255) : (short) 0;
+        handler.pushPromise(i2, this.source.readInt() & Integer.MAX_VALUE, readHeaderBlock(lengthWithoutPadding(i - 4, b, readByte), readByte, b, i2));
+    }
+
+    private void readPing(Handler handler, int i, byte b, int i2) throws IOException {
+        if (i != 8) {
+            throw Http2.ioException("TYPE_PING length != 8: %s", Integer.valueOf(i));
+        }
+        if (i2 != 0) {
+            throw Http2.ioException("TYPE_PING streamId != 0", new Object[0]);
+        }
+        handler.ping((b & 1) != 0, this.source.readInt(), this.source.readInt());
+    }
+
+    private void readGoAway(Handler handler, int i, byte b, int i2) throws IOException {
+        if (i < 8) {
+            throw Http2.ioException("TYPE_GOAWAY length < 8: %s", Integer.valueOf(i));
+        }
+        if (i2 != 0) {
+            throw Http2.ioException("TYPE_GOAWAY streamId != 0", new Object[0]);
+        }
+        int readInt = this.source.readInt();
+        int readInt2 = this.source.readInt();
+        int i3 = i - 8;
+        ErrorCode fromHttp2 = ErrorCode.fromHttp2(readInt2);
+        if (fromHttp2 == null) {
+            throw Http2.ioException("TYPE_GOAWAY unexpected error code: %d", Integer.valueOf(readInt2));
+        }
+        ByteString byteString = ByteString.EMPTY;
+        if (i3 > 0) {
+            byteString = this.source.readByteString(i3);
+        }
+        handler.goAway(readInt, fromHttp2, byteString);
+    }
+
+    private void readWindowUpdate(Handler handler, int i, byte b, int i2) throws IOException {
+        if (i != 4) {
+            throw Http2.ioException("TYPE_WINDOW_UPDATE length !=4: %s", Integer.valueOf(i));
+        }
+        long readInt = this.source.readInt() & 2147483647L;
+        if (readInt == 0) {
+            throw Http2.ioException("windowSizeIncrement was 0", Long.valueOf(readInt));
+        }
+        handler.windowUpdate(i2, readInt);
+    }
+
+    @Override // java.io.Closeable, java.lang.AutoCloseable
+    public void close() throws IOException {
+        this.source.close();
+    }
+
+    public static final class ContinuationSource implements Source {
+        byte flags;
+        int left;
+        int length;
+        short padding;
+        private final BufferedSource source;
+        int streamId;
+
+        @Override // com.mbridge.msdk.thrid.okio.Source, java.io.Closeable, java.lang.AutoCloseable
+        public void close() throws IOException {
+        }
+
+        public ContinuationSource(BufferedSource bufferedSource) {
+            this.source = bufferedSource;
+        }
+
+        @Override // com.mbridge.msdk.thrid.okio.Source
+        public long read(Buffer buffer, long j) throws IOException {
+            while (true) {
+                int i = this.left;
+                if (i == 0) {
+                    this.source.skip(this.padding);
+                    this.padding = (short) 0;
+                    if ((this.flags & 4) != 0) {
+                        return -1L;
+                    }
+                    readContinuationHeader();
+                } else {
+                    long read = this.source.read(buffer, Math.min(j, i));
+                    if (read == -1) {
+                        return -1L;
+                    }
+                    this.left = (int) (this.left - read);
+                    return read;
+                }
+            }
+        }
+
+        @Override // com.mbridge.msdk.thrid.okio.Source
+        public Timeout timeout() {
+            return this.source.timeout();
+        }
+
+        private void readContinuationHeader() throws IOException {
+            int i = this.streamId;
+            int readMedium = Http2Reader.readMedium(this.source);
+            this.left = readMedium;
+            this.length = readMedium;
+            byte readByte = (byte) (this.source.readByte() & 255);
+            this.flags = (byte) (this.source.readByte() & 255);
+            Logger logger = Http2Reader.logger;
+            if (logger.isLoggable(Level.FINE)) {
+                logger.fine(Http2.frameLog(true, this.streamId, this.length, readByte, this.flags));
+            }
+            int readInt = this.source.readInt() & Integer.MAX_VALUE;
+            this.streamId = readInt;
+            if (readByte != 9) {
+                throw Http2.ioException("%s != TYPE_CONTINUATION", Byte.valueOf(readByte));
+            }
+            if (readInt != i) {
+                throw Http2.ioException("TYPE_CONTINUATION streamId changed", new Object[0]);
+            }
+        }
+    }
+
+    public static int readMedium(BufferedSource bufferedSource) throws IOException {
+        return (bufferedSource.readByte() & 255) | ((bufferedSource.readByte() & 255) << 16) | ((bufferedSource.readByte() & 255) << 8);
+    }
+
+    public static int lengthWithoutPadding(int i, byte b, short s) throws IOException {
+        if ((b & 8) != 0) {
+            i--;
+        }
+        if (s <= i) {
+            return (short) (i - s);
+        }
+        throw Http2.ioException("PROTOCOL_ERROR padding %s > remaining length %s", Short.valueOf(s), Integer.valueOf(i));
+    }
+}

decompiled/sources/com/mbridge/msdk/thrid/okhttp/internal/http2/Http2Stream.java

@@ -0,0 +1,615 @@
+package com.mbridge.msdk.thrid.okhttp.internal.http2;
+
+import com.mbridge.msdk.thrid.okhttp.Headers;
+import com.mbridge.msdk.thrid.okhttp.internal.Util;
+import com.mbridge.msdk.thrid.okhttp.internal.http2.Header;
+import com.mbridge.msdk.thrid.okio.AsyncTimeout;
+import com.mbridge.msdk.thrid.okio.Buffer;
+import com.mbridge.msdk.thrid.okio.BufferedSource;
+import com.mbridge.msdk.thrid.okio.Sink;
+import com.mbridge.msdk.thrid.okio.Source;
+import com.mbridge.msdk.thrid.okio.Timeout;
+import java.io.EOFException;
+import java.io.IOException;
+import java.io.InterruptedIOException;
+import java.net.SocketTimeoutException;
+import java.util.ArrayDeque;
+import java.util.ArrayList;
+import java.util.Deque;
+import java.util.Iterator;
+import java.util.List;
+
+/* loaded from: classes4.dex */
+public final class Http2Stream {
+    static final /* synthetic */ boolean $assertionsDisabled = false;
+    long bytesLeftInWriteWindow;
+    final Http2Connection connection;
+    ErrorCode errorCode;
+    private boolean hasResponseHeaders;
+    private Header.Listener headersListener;
+    private final Deque<Headers> headersQueue;
+    final int id;
+    final StreamTimeout readTimeout;
+    final FramingSink sink;
+    private final FramingSource source;
+    long unacknowledgedBytesRead = 0;
+    final StreamTimeout writeTimeout;
+
+    public Http2Connection getConnection() {
+        return this.connection;
+    }
+
+    public int getId() {
+        return this.id;
+    }
+
+    public Source getSource() {
+        return this.source;
+    }
+
+    public Timeout readTimeout() {
+        return this.readTimeout;
+    }
+
+    public Timeout writeTimeout() {
+        return this.writeTimeout;
+    }
+
+    public Http2Stream(int i, Http2Connection http2Connection, boolean z, boolean z2, Headers headers) {
+        ArrayDeque arrayDeque = new ArrayDeque();
+        this.headersQueue = arrayDeque;
+        this.readTimeout = new StreamTimeout();
+        this.writeTimeout = new StreamTimeout();
+        this.errorCode = null;
+        if (http2Connection == null) {
+            throw new NullPointerException("connection == null");
+        }
+        this.id = i;
+        this.connection = http2Connection;
+        this.bytesLeftInWriteWindow = http2Connection.peerSettings.getInitialWindowSize();
+        FramingSource framingSource = new FramingSource(http2Connection.okHttpSettings.getInitialWindowSize());
+        this.source = framingSource;
+        FramingSink framingSink = new FramingSink();
+        this.sink = framingSink;
+        framingSource.finished = z2;
+        framingSink.finished = z;
+        if (headers != null) {
+            arrayDeque.add(headers);
+        }
+        if (isLocallyInitiated() && headers != null) {
+            throw new IllegalStateException("locally-initiated streams shouldn't have headers yet");
+        }
+        if (!isLocallyInitiated() && headers == null) {
+            throw new IllegalStateException("remotely-initiated streams should have headers");
+        }
+    }
+
+    public synchronized boolean isOpen() {
+        try {
+            if (this.errorCode != null) {
+                return false;
+            }
+            FramingSource framingSource = this.source;
+            if (!framingSource.finished) {
+                if (framingSource.closed) {
+                }
+                return true;
+            }
+            FramingSink framingSink = this.sink;
+            if (framingSink.finished || framingSink.closed) {
+                if (this.hasResponseHeaders) {
+                    return false;
+                }
+            }
+            return true;
+        } catch (Throwable th) {
+            throw th;
+        }
+    }
+
+    public boolean isLocallyInitiated() {
+        return this.connection.client == ((this.id & 1) == 1);
+    }
+
+    public synchronized Headers takeHeaders() throws IOException {
+        this.readTimeout.enter();
+        while (this.headersQueue.isEmpty() && this.errorCode == null) {
+            try {
+                waitForIo();
+            } catch (Throwable th) {
+                this.readTimeout.exitAndThrowIfTimedOut();
+                throw th;
+            }
+        }
+        this.readTimeout.exitAndThrowIfTimedOut();
+        if (!this.headersQueue.isEmpty()) {
+        } else {
+            throw new StreamResetException(this.errorCode);
+        }
+        return this.headersQueue.removeFirst();
+    }
+
+    public synchronized ErrorCode getErrorCode() {
+        return this.errorCode;
+    }
+
+    public void writeHeaders(List<Header> list, boolean z) throws IOException {
+        boolean z2;
+        boolean z3;
+        boolean z4;
+        if (list == null) {
+            throw new NullPointerException("headers == null");
+        }
+        synchronized (this) {
+            z2 = true;
+            try {
+                this.hasResponseHeaders = true;
+                if (z) {
+                    z3 = false;
+                } else {
+                    this.sink.finished = true;
+                    z3 = true;
+                }
+                z4 = z3;
+            } finally {
+            }
+        }
+        if (!z3) {
+            synchronized (this.connection) {
+                if (this.connection.bytesLeftInWriteWindow != 0) {
+                    z2 = false;
+                }
+            }
+            z3 = z2;
+        }
+        this.connection.writeSynReply(this.id, z4, list);
+        if (z3) {
+            this.connection.flush();
+        }
+    }
+
+    public Sink getSink() {
+        synchronized (this) {
+            try {
+                if (!this.hasResponseHeaders && !isLocallyInitiated()) {
+                    throw new IllegalStateException("reply before requesting the sink");
+                }
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+        return this.sink;
+    }
+
+    public void close(ErrorCode errorCode) throws IOException {
+        if (closeInternal(errorCode)) {
+            this.connection.writeSynReset(this.id, errorCode);
+        }
+    }
+
+    public void closeLater(ErrorCode errorCode) {
+        if (closeInternal(errorCode)) {
+            this.connection.writeSynResetLater(this.id, errorCode);
+        }
+    }
+
+    private boolean closeInternal(ErrorCode errorCode) {
+        synchronized (this) {
+            try {
+                if (this.errorCode != null) {
+                    return false;
+                }
+                if (this.source.finished && this.sink.finished) {
+                    return false;
+                }
+                this.errorCode = errorCode;
+                notifyAll();
+                this.connection.removeStream(this.id);
+                return true;
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+    }
+
+    public void receiveHeaders(List<Header> list) {
+        boolean isOpen;
+        synchronized (this) {
+            this.hasResponseHeaders = true;
+            this.headersQueue.add(Util.toHeaders(list));
+            isOpen = isOpen();
+            notifyAll();
+        }
+        if (isOpen) {
+            return;
+        }
+        this.connection.removeStream(this.id);
+    }
+
+    public void receiveData(BufferedSource bufferedSource, int i) throws IOException {
+        this.source.receive(bufferedSource, i);
+    }
+
+    public void receiveFin() {
+        boolean isOpen;
+        synchronized (this) {
+            this.source.finished = true;
+            isOpen = isOpen();
+            notifyAll();
+        }
+        if (isOpen) {
+            return;
+        }
+        this.connection.removeStream(this.id);
+    }
+
+    public synchronized void receiveRstStream(ErrorCode errorCode) {
+        if (this.errorCode == null) {
+            this.errorCode = errorCode;
+            notifyAll();
+        }
+    }
+
+    public synchronized void setHeadersListener(Header.Listener listener) {
+        this.headersListener = listener;
+        if (!this.headersQueue.isEmpty() && listener != null) {
+            notifyAll();
+        }
+    }
+
+    public final class FramingSource implements Source {
+        static final /* synthetic */ boolean $assertionsDisabled = false;
+        boolean closed;
+        boolean finished;
+        private final long maxByteCount;
+        private final Buffer receiveBuffer = new Buffer();
+        private final Buffer readBuffer = new Buffer();
+
+        public FramingSource(long j) {
+            this.maxByteCount = j;
+        }
+
+        @Override // com.mbridge.msdk.thrid.okio.Source
+        public long read(Buffer buffer, long j) throws IOException {
+            ErrorCode errorCode;
+            long read;
+            Headers headers;
+            Header.Listener listener;
+            if (j < 0) {
+                throw new IllegalArgumentException("byteCount < 0: " + j);
+            }
+            while (true) {
+                synchronized (Http2Stream.this) {
+                    try {
+                        Http2Stream.this.readTimeout.enter();
+                        try {
+                            Http2Stream http2Stream = Http2Stream.this;
+                            errorCode = http2Stream.errorCode;
+                            if (errorCode == null) {
+                                errorCode = null;
+                            }
+                            if (!this.closed) {
+                                if (!http2Stream.headersQueue.isEmpty() && Http2Stream.this.headersListener != null) {
+                                    headers = (Headers) Http2Stream.this.headersQueue.removeFirst();
+                                    listener = Http2Stream.this.headersListener;
+                                } else if (this.readBuffer.size() > 0) {
+                                    Buffer buffer2 = this.readBuffer;
+                                    read = buffer2.read(buffer, Math.min(j, buffer2.size()));
+                                    Http2Stream http2Stream2 = Http2Stream.this;
+                                    long j2 = http2Stream2.unacknowledgedBytesRead + read;
+                                    http2Stream2.unacknowledgedBytesRead = j2;
+                                    if (errorCode == null && j2 >= http2Stream2.connection.okHttpSettings.getInitialWindowSize() / 2) {
+                                        Http2Stream http2Stream3 = Http2Stream.this;
+                                        http2Stream3.connection.writeWindowUpdateLater(http2Stream3.id, http2Stream3.unacknowledgedBytesRead);
+                                        Http2Stream.this.unacknowledgedBytesRead = 0L;
+                                    }
+                                    headers = null;
+                                    listener = null;
+                                    if (headers == null || listener == null) {
+                                        break;
+                                    }
+                                    listener.onHeaders(headers);
+                                } else if (this.finished || errorCode != null) {
+                                    headers = null;
+                                    listener = null;
+                                } else {
+                                    Http2Stream.this.waitForIo();
+                                    Http2Stream.this.readTimeout.exitAndThrowIfTimedOut();
+                                }
+                                read = -1;
+                                if (headers == null) {
+                                    break;
+                                }
+                                break;
+                            }
+                            throw new IOException("stream closed");
+                        } finally {
+                            Http2Stream.this.readTimeout.exitAndThrowIfTimedOut();
+                        }
+                    } catch (Throwable th) {
+                        throw th;
+                    }
+                }
+            }
+            if (read != -1) {
+                updateConnectionFlowControl(read);
+                return read;
+            }
+            if (errorCode == null) {
+                return -1L;
+            }
+            throw new StreamResetException(errorCode);
+        }
+
+        private void updateConnectionFlowControl(long j) {
+            Http2Stream.this.connection.updateConnectionFlowControl(j);
+        }
+
+        public void receive(BufferedSource bufferedSource, long j) throws IOException {
+            boolean z;
+            boolean z2;
+            long j2;
+            while (j > 0) {
+                synchronized (Http2Stream.this) {
+                    z = this.finished;
+                    z2 = this.readBuffer.size() + j > this.maxByteCount;
+                }
+                if (z2) {
+                    bufferedSource.skip(j);
+                    Http2Stream.this.closeLater(ErrorCode.FLOW_CONTROL_ERROR);
+                    return;
+                }
+                if (z) {
+                    bufferedSource.skip(j);
+                    return;
+                }
+                long read = bufferedSource.read(this.receiveBuffer, j);
+                if (read == -1) {
+                    throw new EOFException();
+                }
+                j -= read;
+                synchronized (Http2Stream.this) {
+                    try {
+                        if (this.closed) {
+                            j2 = this.receiveBuffer.size();
+                            this.receiveBuffer.clear();
+                        } else {
+                            boolean z3 = this.readBuffer.size() == 0;
+                            this.readBuffer.writeAll(this.receiveBuffer);
+                            if (z3) {
+                                Http2Stream.this.notifyAll();
+                            }
+                            j2 = 0;
+                        }
+                    } finally {
+                    }
+                }
+                if (j2 > 0) {
+                    updateConnectionFlowControl(j2);
+                }
+            }
+        }
+
+        @Override // com.mbridge.msdk.thrid.okio.Source
+        public Timeout timeout() {
+            return Http2Stream.this.readTimeout;
+        }
+
+        @Override // com.mbridge.msdk.thrid.okio.Source, java.io.Closeable, java.lang.AutoCloseable
+        public void close() throws IOException {
+            long size;
+            ArrayList arrayList;
+            Header.Listener listener;
+            synchronized (Http2Stream.this) {
+                try {
+                    this.closed = true;
+                    size = this.readBuffer.size();
+                    this.readBuffer.clear();
+                    if (Http2Stream.this.headersQueue.isEmpty() || Http2Stream.this.headersListener == null) {
+                        arrayList = null;
+                        listener = null;
+                    } else {
+                        arrayList = new ArrayList(Http2Stream.this.headersQueue);
+                        Http2Stream.this.headersQueue.clear();
+                        listener = Http2Stream.this.headersListener;
+                    }
+                    Http2Stream.this.notifyAll();
+                } catch (Throwable th) {
+                    throw th;
+                }
+            }
+            if (size > 0) {
+                updateConnectionFlowControl(size);
+            }
+            Http2Stream.this.cancelStreamIfNecessary();
+            if (listener != null) {
+                Iterator it = arrayList.iterator();
+                while (it.hasNext()) {
+                    listener.onHeaders((Headers) it.next());
+                }
+            }
+        }
+    }
+
+    public void cancelStreamIfNecessary() throws IOException {
+        boolean z;
+        boolean isOpen;
+        synchronized (this) {
+            try {
+                FramingSource framingSource = this.source;
+                if (!framingSource.finished && framingSource.closed) {
+                    FramingSink framingSink = this.sink;
+                    if (!framingSink.finished) {
+                        if (framingSink.closed) {
+                        }
+                    }
+                    z = true;
+                    isOpen = isOpen();
+                }
+                z = false;
+                isOpen = isOpen();
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+        if (z) {
+            close(ErrorCode.CANCEL);
+        } else {
+            if (isOpen) {
+                return;
+            }
+            this.connection.removeStream(this.id);
+        }
+    }
+
+    public final class FramingSink implements Sink {
+        static final /* synthetic */ boolean $assertionsDisabled = false;
+        private static final long EMIT_BUFFER_SIZE = 16384;
+        boolean closed;
+        boolean finished;
+        private final Buffer sendBuffer = new Buffer();
+
+        public FramingSink() {
+        }
+
+        @Override // com.mbridge.msdk.thrid.okio.Sink
+        public void write(Buffer buffer, long j) throws IOException {
+            this.sendBuffer.write(buffer, j);
+            while (this.sendBuffer.size() >= 16384) {
+                emitFrame(false);
+            }
+        }
+
+        private void emitFrame(boolean z) throws IOException {
+            Http2Stream http2Stream;
+            long min;
+            Http2Stream http2Stream2;
+            synchronized (Http2Stream.this) {
+                Http2Stream.this.writeTimeout.enter();
+                while (true) {
+                    try {
+                        http2Stream = Http2Stream.this;
+                        if (http2Stream.bytesLeftInWriteWindow > 0 || this.finished || this.closed || http2Stream.errorCode != null) {
+                            break;
+                        } else {
+                            http2Stream.waitForIo();
+                        }
+                    } finally {
+                        Http2Stream.this.writeTimeout.exitAndThrowIfTimedOut();
+                    }
+                }
+                http2Stream.writeTimeout.exitAndThrowIfTimedOut();
+                Http2Stream.this.checkOutNotClosed();
+                min = Math.min(Http2Stream.this.bytesLeftInWriteWindow, this.sendBuffer.size());
+                http2Stream2 = Http2Stream.this;
+                http2Stream2.bytesLeftInWriteWindow -= min;
+            }
+            http2Stream2.writeTimeout.enter();
+            try {
+                Http2Stream http2Stream3 = Http2Stream.this;
+                http2Stream3.connection.writeData(http2Stream3.id, z && min == this.sendBuffer.size(), this.sendBuffer, min);
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+
+        @Override // com.mbridge.msdk.thrid.okio.Sink, java.io.Flushable
+        public void flush() throws IOException {
+            synchronized (Http2Stream.this) {
+                Http2Stream.this.checkOutNotClosed();
+            }
+            while (this.sendBuffer.size() > 0) {
+                emitFrame(false);
+                Http2Stream.this.connection.flush();
+            }
+        }
+
+        @Override // com.mbridge.msdk.thrid.okio.Sink
+        public Timeout timeout() {
+            return Http2Stream.this.writeTimeout;
+        }
+
+        @Override // com.mbridge.msdk.thrid.okio.Sink, java.io.Closeable, java.lang.AutoCloseable
+        public void close() throws IOException {
+            synchronized (Http2Stream.this) {
+                try {
+                    if (this.closed) {
+                        return;
+                    }
+                    if (!Http2Stream.this.sink.finished) {
+                        if (this.sendBuffer.size() > 0) {
+                            while (this.sendBuffer.size() > 0) {
+                                emitFrame(true);
+                            }
+                        } else {
+                            Http2Stream http2Stream = Http2Stream.this;
+                            http2Stream.connection.writeData(http2Stream.id, true, null, 0L);
+                        }
+                    }
+                    synchronized (Http2Stream.this) {
+                        this.closed = true;
+                    }
+                    Http2Stream.this.connection.flush();
+                    Http2Stream.this.cancelStreamIfNecessary();
+                } catch (Throwable th) {
+                    throw th;
+                }
+            }
+        }
+    }
+
+    public void addBytesToWriteWindow(long j) {
+        this.bytesLeftInWriteWindow += j;
+        if (j > 0) {
+            notifyAll();
+        }
+    }
+
+    public void checkOutNotClosed() throws IOException {
+        FramingSink framingSink = this.sink;
+        if (framingSink.closed) {
+            throw new IOException("stream closed");
+        }
+        if (framingSink.finished) {
+            throw new IOException("stream finished");
+        }
+        if (this.errorCode != null) {
+            throw new StreamResetException(this.errorCode);
+        }
+    }
+
+    public void waitForIo() throws InterruptedIOException {
+        try {
+            wait();
+        } catch (InterruptedException unused) {
+            Thread.currentThread().interrupt();
+            throw new InterruptedIOException();
+        }
+    }
+
+    public class StreamTimeout extends AsyncTimeout {
+        public StreamTimeout() {
+        }
+
+        @Override // com.mbridge.msdk.thrid.okio.AsyncTimeout
+        public void timedOut() {
+            Http2Stream.this.closeLater(ErrorCode.CANCEL);
+            Http2Stream.this.connection.sendDegradedPingLater();
+        }
+
+        @Override // com.mbridge.msdk.thrid.okio.AsyncTimeout
+        public IOException newTimeoutException(IOException iOException) {
+            SocketTimeoutException socketTimeoutException = new SocketTimeoutException("timeout");
+            if (iOException != null) {
+                socketTimeoutException.initCause(iOException);
+            }
+            return socketTimeoutException;
+        }
+
+        public void exitAndThrowIfTimedOut() throws IOException {
+            if (exit()) {
+                throw newTimeoutException(null);
+            }
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/thrid/okhttp/internal/http2/Http2Writer.java

@@ -0,0 +1,261 @@
+package com.mbridge.msdk.thrid.okhttp.internal.http2;
+
+import com.mbridge.msdk.thrid.okhttp.internal.Util;
+import com.mbridge.msdk.thrid.okhttp.internal.http2.Hpack;
+import com.mbridge.msdk.thrid.okio.Buffer;
+import com.mbridge.msdk.thrid.okio.BufferedSink;
+import csdk.gluads.Consts;
+import java.io.Closeable;
+import java.io.IOException;
+import java.util.List;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+/* loaded from: classes4.dex */
+final class Http2Writer implements Closeable {
+    private static final Logger logger = Logger.getLogger(Http2.class.getName());
+    private final boolean client;
+    private boolean closed;
+    private final Buffer hpackBuffer;
+    final Hpack.Writer hpackWriter;
+    private int maxFrameSize;
+    private final BufferedSink sink;
+
+    public int maxDataLength() {
+        return this.maxFrameSize;
+    }
+
+    public Http2Writer(BufferedSink bufferedSink, boolean z) {
+        this.sink = bufferedSink;
+        this.client = z;
+        Buffer buffer = new Buffer();
+        this.hpackBuffer = buffer;
+        this.hpackWriter = new Hpack.Writer(buffer);
+        this.maxFrameSize = 16384;
+    }
+
+    public synchronized void connectionPreface() throws IOException {
+        try {
+            if (this.closed) {
+                throw new IOException(Consts.PLACEMENT_STATUS_CLOSED);
+            }
+            if (this.client) {
+                Logger logger2 = logger;
+                if (logger2.isLoggable(Level.FINE)) {
+                    logger2.fine(Util.format(">> CONNECTION %s", Http2.CONNECTION_PREFACE.hex()));
+                }
+                this.sink.write(Http2.CONNECTION_PREFACE.toByteArray());
+                this.sink.flush();
+            }
+        } catch (Throwable th) {
+            throw th;
+        }
+    }
+
+    public synchronized void applyAndAckSettings(Settings settings) throws IOException {
+        try {
+            if (this.closed) {
+                throw new IOException(Consts.PLACEMENT_STATUS_CLOSED);
+            }
+            this.maxFrameSize = settings.getMaxFrameSize(this.maxFrameSize);
+            if (settings.getHeaderTableSize() != -1) {
+                this.hpackWriter.setHeaderTableSizeSetting(settings.getHeaderTableSize());
+            }
+            frameHeader(0, 0, (byte) 4, (byte) 1);
+            this.sink.flush();
+        } catch (Throwable th) {
+            throw th;
+        }
+    }
+
+    public synchronized void pushPromise(int i, int i2, List<Header> list) throws IOException {
+        if (this.closed) {
+            throw new IOException(Consts.PLACEMENT_STATUS_CLOSED);
+        }
+        this.hpackWriter.writeHeaders(list);
+        long size = this.hpackBuffer.size();
+        int min = (int) Math.min(this.maxFrameSize - 4, size);
+        long j = min;
+        frameHeader(i, min + 4, (byte) 5, size == j ? (byte) 4 : (byte) 0);
+        this.sink.writeInt(i2 & Integer.MAX_VALUE);
+        this.sink.write(this.hpackBuffer, j);
+        if (size > j) {
+            writeContinuationFrames(i, size - j);
+        }
+    }
+
+    public synchronized void flush() throws IOException {
+        if (this.closed) {
+            throw new IOException(Consts.PLACEMENT_STATUS_CLOSED);
+        }
+        this.sink.flush();
+    }
+
+    public synchronized void synStream(boolean z, int i, int i2, List<Header> list) throws IOException {
+        if (this.closed) {
+            throw new IOException(Consts.PLACEMENT_STATUS_CLOSED);
+        }
+        headers(z, i, list);
+    }
+
+    public synchronized void synReply(boolean z, int i, List<Header> list) throws IOException {
+        if (this.closed) {
+            throw new IOException(Consts.PLACEMENT_STATUS_CLOSED);
+        }
+        headers(z, i, list);
+    }
+
+    public synchronized void headers(int i, List<Header> list) throws IOException {
+        if (this.closed) {
+            throw new IOException(Consts.PLACEMENT_STATUS_CLOSED);
+        }
+        headers(false, i, list);
+    }
+
+    public synchronized void rstStream(int i, ErrorCode errorCode) throws IOException {
+        if (this.closed) {
+            throw new IOException(Consts.PLACEMENT_STATUS_CLOSED);
+        }
+        if (errorCode.httpCode == -1) {
+            throw new IllegalArgumentException();
+        }
+        frameHeader(i, 4, (byte) 3, (byte) 0);
+        this.sink.writeInt(errorCode.httpCode);
+        this.sink.flush();
+    }
+
+    public synchronized void data(boolean z, int i, Buffer buffer, int i2) throws IOException {
+        if (this.closed) {
+            throw new IOException(Consts.PLACEMENT_STATUS_CLOSED);
+        }
+        dataFrame(i, z ? (byte) 1 : (byte) 0, buffer, i2);
+    }
+
+    public void dataFrame(int i, byte b, Buffer buffer, int i2) throws IOException {
+        frameHeader(i, i2, (byte) 0, b);
+        if (i2 > 0) {
+            this.sink.write(buffer, i2);
+        }
+    }
+
+    public synchronized void settings(Settings settings) throws IOException {
+        try {
+            if (this.closed) {
+                throw new IOException(Consts.PLACEMENT_STATUS_CLOSED);
+            }
+            int i = 0;
+            frameHeader(0, settings.size() * 6, (byte) 4, (byte) 0);
+            while (i < 10) {
+                if (settings.isSet(i)) {
+                    this.sink.writeShort(i == 4 ? 3 : i == 7 ? 4 : i);
+                    this.sink.writeInt(settings.get(i));
+                }
+                i++;
+            }
+            this.sink.flush();
+        } catch (Throwable th) {
+            throw th;
+        }
+    }
+
+    public synchronized void ping(boolean z, int i, int i2) throws IOException {
+        if (this.closed) {
+            throw new IOException(Consts.PLACEMENT_STATUS_CLOSED);
+        }
+        frameHeader(0, 8, (byte) 6, z ? (byte) 1 : (byte) 0);
+        this.sink.writeInt(i);
+        this.sink.writeInt(i2);
+        this.sink.flush();
+    }
+
+    public synchronized void goAway(int i, ErrorCode errorCode, byte[] bArr) throws IOException {
+        try {
+            if (this.closed) {
+                throw new IOException(Consts.PLACEMENT_STATUS_CLOSED);
+            }
+            if (errorCode.httpCode == -1) {
+                throw Http2.illegalArgument("errorCode.httpCode == -1", new Object[0]);
+            }
+            frameHeader(0, bArr.length + 8, (byte) 7, (byte) 0);
+            this.sink.writeInt(i);
+            this.sink.writeInt(errorCode.httpCode);
+            if (bArr.length > 0) {
+                this.sink.write(bArr);
+            }
+            this.sink.flush();
+        } catch (Throwable th) {
+            throw th;
+        }
+    }
+
+    public synchronized void windowUpdate(int i, long j) throws IOException {
+        if (this.closed) {
+            throw new IOException(Consts.PLACEMENT_STATUS_CLOSED);
+        }
+        if (j == 0 || j > 2147483647L) {
+            throw Http2.illegalArgument("windowSizeIncrement == 0 || windowSizeIncrement > 0x7fffffffL: %s", Long.valueOf(j));
+        }
+        frameHeader(i, 4, (byte) 8, (byte) 0);
+        this.sink.writeInt((int) j);
+        this.sink.flush();
+    }
+
+    public void frameHeader(int i, int i2, byte b, byte b2) throws IOException {
+        Logger logger2 = logger;
+        if (logger2.isLoggable(Level.FINE)) {
+            logger2.fine(Http2.frameLog(false, i, i2, b, b2));
+        }
+        int i3 = this.maxFrameSize;
+        if (i2 > i3) {
+            throw Http2.illegalArgument("FRAME_SIZE_ERROR length > %d: %d", Integer.valueOf(i3), Integer.valueOf(i2));
+        }
+        if ((Integer.MIN_VALUE & i) != 0) {
+            throw Http2.illegalArgument("reserved bit set: %s", Integer.valueOf(i));
+        }
+        writeMedium(this.sink, i2);
+        this.sink.writeByte(b & 255);
+        this.sink.writeByte(b2 & 255);
+        this.sink.writeInt(i & Integer.MAX_VALUE);
+    }
+
+    @Override // java.io.Closeable, java.lang.AutoCloseable
+    public synchronized void close() throws IOException {
+        this.closed = true;
+        this.sink.close();
+    }
+
+    private static void writeMedium(BufferedSink bufferedSink, int i) throws IOException {
+        bufferedSink.writeByte((i >>> 16) & 255);
+        bufferedSink.writeByte((i >>> 8) & 255);
+        bufferedSink.writeByte(i & 255);
+    }
+
+    private void writeContinuationFrames(int i, long j) throws IOException {
+        while (j > 0) {
+            int min = (int) Math.min(this.maxFrameSize, j);
+            long j2 = min;
+            j -= j2;
+            frameHeader(i, min, (byte) 9, j == 0 ? (byte) 4 : (byte) 0);
+            this.sink.write(this.hpackBuffer, j2);
+        }
+    }
+
+    public void headers(boolean z, int i, List<Header> list) throws IOException {
+        if (this.closed) {
+            throw new IOException(Consts.PLACEMENT_STATUS_CLOSED);
+        }
+        this.hpackWriter.writeHeaders(list);
+        long size = this.hpackBuffer.size();
+        int min = (int) Math.min(this.maxFrameSize, size);
+        long j = min;
+        byte b = size == j ? (byte) 4 : (byte) 0;
+        if (z) {
+            b = (byte) (b | 1);
+        }
+        frameHeader(i, min, (byte) 1, b);
+        this.sink.write(this.hpackBuffer, j);
+        if (size > j) {
+            writeContinuationFrames(i, size - j);
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/thrid/okhttp/internal/http2/Huffman.java

@@ -0,0 +1,137 @@
+package com.mbridge.msdk.thrid.okhttp.internal.http2;
+
+import androidx.core.view.PointerIconCompat;
+import com.applovin.exoplayer2.common.base.Ascii;
+import com.mbridge.msdk.thrid.okio.BufferedSink;
+import com.mbridge.msdk.thrid.okio.ByteString;
+import com.vungle.ads.internal.signals.SignalKey;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+
+/* loaded from: classes4.dex */
+class Huffman {
+    private static final int[] CODES = {8184, 8388568, 268435426, 268435427, 268435428, 268435429, 268435430, 268435431, 268435432, 16777194, 1073741820, 268435433, 268435434, 1073741821, 268435435, 268435436, 268435437, 268435438, 268435439, 268435440, 268435441, 268435442, 1073741822, 268435443, 268435444, 268435445, 268435446, 268435447, 268435448, 268435449, 268435450, 268435451, 20, 1016, PointerIconCompat.TYPE_TOP_LEFT_DIAGONAL_DOUBLE_ARROW, 4090, 8185, 21, 248, 2042, 1018, 1019, 249, 2043, 250, 22, 23, 24, 0, 1, 2, 25, 26, 27, 28, 29, 30, 31, 92, 251, 32764, 32, 4091, 1020, 8186, 33, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, SignalKey.EVENT_ID, 108, 109, 110, 111, 112, 113, 114, 252, 115, 253, 8187, 524272, 8188, 16380, 34, 32765, 3, 35, 4, 36, 5, 37, 38, 39, 6, 116, 117, 40, 41, 42, 7, 43, 118, 44, 8, 9, 45, 119, 120, 121, 122, 123, 32766, 2044, 16381, 8189, 268435452, 1048550, 4194258, 1048551, 1048552, 4194259, 4194260, 4194261, 8388569, 4194262, 8388570, 8388571, 8388572, 8388573, 8388574, 16777195, 8388575, 16777196, 16777197, 4194263, 8388576, 16777198, 8388577, 8388578, 8388579, 8388580, 2097116, 4194264, 8388581, 4194265, 8388582, 8388583, 16777199, 4194266, 2097117, 1048553, 4194267, 4194268, 8388584, 8388585, 2097118, 8388586, 4194269, 4194270, 16777200, 2097119, 4194271, 8388587, 8388588, 2097120, 2097121, 4194272, 2097122, 8388589, 4194273, 8388590, 8388591, 1048554, 4194274, 4194275, 4194276, 8388592, 4194277, 4194278, 8388593, 67108832, 67108833, 1048555, 524273, 4194279, 8388594, 4194280, 33554412, 67108834, 67108835, 67108836, 134217694, 134217695, 67108837, 16777201, 33554413, 524274, 2097123, 67108838, 134217696, 134217697, 67108839, 134217698, 16777202, 2097124, 2097125, 67108840, 67108841, 268435453, 134217699, 134217700, 134217701, 1048556, 16777203, 1048557, 2097126, 4194281, 2097127, 2097128, 8388595, 4194282, 4194283, 33554414, 33554415, 16777204, 16777205, 67108842, 8388596, 67108843, 134217702, 67108844, 67108845, 134217703, 134217704, 134217705, 134217706, 134217707, 268435454, 134217708, 134217709, 134217710, 134217711, 134217712, 67108846};
+    private static final byte[] CODE_LENGTHS = {Ascii.CR, Ascii.ETB, Ascii.FS, Ascii.FS, Ascii.FS, Ascii.FS, Ascii.FS, Ascii.FS, Ascii.FS, Ascii.CAN, Ascii.RS, Ascii.FS, Ascii.FS, Ascii.RS, Ascii.FS, Ascii.FS, Ascii.FS, Ascii.FS, Ascii.FS, Ascii.FS, Ascii.FS, Ascii.FS, Ascii.RS, Ascii.FS, Ascii.FS, Ascii.FS, Ascii.FS, Ascii.FS, Ascii.FS, Ascii.FS, Ascii.FS, Ascii.FS, 6, 10, 10, Ascii.FF, Ascii.CR, 6, 8, Ascii.VT, 10, 10, 8, Ascii.VT, 8, 6, 6, 6, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 7, 8, Ascii.SI, 6, Ascii.FF, 10, Ascii.CR, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 8, 7, 8, Ascii.CR, 19, Ascii.CR, Ascii.SO, 6, Ascii.SI, 5, 6, 5, 6, 5, 6, 6, 6, 5, 7, 7, 6, 6, 6, 5, 6, 7, 6, 5, 5, 6, 7, 7, 7, 7, 7, Ascii.SI, Ascii.VT, Ascii.SO, Ascii.CR, Ascii.FS, Ascii.DC4, Ascii.SYN, Ascii.DC4, Ascii.DC4, Ascii.SYN, Ascii.SYN, Ascii.SYN, Ascii.ETB, Ascii.SYN, Ascii.ETB, Ascii.ETB, Ascii.ETB, Ascii.ETB, Ascii.ETB, Ascii.CAN, Ascii.ETB, Ascii.CAN, Ascii.CAN, Ascii.SYN, Ascii.ETB, Ascii.CAN, Ascii.ETB, Ascii.ETB, Ascii.ETB, Ascii.ETB, Ascii.NAK, Ascii.SYN, Ascii.ETB, Ascii.SYN, Ascii.ETB, Ascii.ETB, Ascii.CAN, Ascii.SYN, Ascii.NAK, Ascii.DC4, Ascii.SYN, Ascii.SYN, Ascii.ETB, Ascii.ETB, Ascii.NAK, Ascii.ETB, Ascii.SYN, Ascii.SYN, Ascii.CAN, Ascii.NAK, Ascii.SYN, Ascii.ETB, Ascii.ETB, Ascii.NAK, Ascii.NAK, Ascii.SYN, Ascii.NAK, Ascii.ETB, Ascii.SYN, Ascii.ETB, Ascii.ETB, Ascii.DC4, Ascii.SYN, Ascii.SYN, Ascii.SYN, Ascii.ETB, Ascii.SYN, Ascii.SYN, Ascii.ETB, Ascii.SUB, Ascii.SUB, Ascii.DC4, 19, Ascii.SYN, Ascii.ETB, Ascii.SYN, Ascii.EM, Ascii.SUB, Ascii.SUB, Ascii.SUB, Ascii.ESC, Ascii.ESC, Ascii.SUB, Ascii.CAN, Ascii.EM, 19, Ascii.NAK, Ascii.SUB, Ascii.ESC, Ascii.ESC, Ascii.SUB, Ascii.ESC, Ascii.CAN, Ascii.NAK, Ascii.NAK, Ascii.SUB, Ascii.SUB, Ascii.FS, Ascii.ESC, Ascii.ESC, Ascii.ESC, Ascii.DC4, Ascii.CAN, Ascii.DC4, Ascii.NAK, Ascii.SYN, Ascii.NAK, Ascii.NAK, Ascii.ETB, Ascii.SYN, Ascii.SYN, Ascii.EM, Ascii.EM, Ascii.CAN, Ascii.CAN, Ascii.SUB, Ascii.ETB, Ascii.SUB, Ascii.ESC, Ascii.SUB, Ascii.SUB, Ascii.ESC, Ascii.ESC, Ascii.ESC, Ascii.ESC, Ascii.ESC, Ascii.FS, Ascii.ESC, Ascii.ESC, Ascii.ESC, Ascii.ESC, Ascii.ESC, Ascii.SUB};
+    private static final Huffman INSTANCE = new Huffman();
+    private final Node root = new Node();
+
+    public static Huffman get() {
+        return INSTANCE;
+    }
+
+    private Huffman() {
+        buildTree();
+    }
+
+    public void encode(ByteString byteString, BufferedSink bufferedSink) throws IOException {
+        long j = 0;
+        int i = 0;
+        for (int i2 = 0; i2 < byteString.size(); i2++) {
+            int i3 = byteString.getByte(i2) & 255;
+            int i4 = CODES[i3];
+            byte b = CODE_LENGTHS[i3];
+            j = (j << b) | i4;
+            i += b;
+            while (i >= 8) {
+                i -= 8;
+                bufferedSink.writeByte((int) (j >> i));
+            }
+        }
+        if (i > 0) {
+            bufferedSink.writeByte((int) ((j << (8 - i)) | (255 >>> i)));
+        }
+    }
+
+    public int encodedLength(ByteString byteString) {
+        long j = 0;
+        for (int i = 0; i < byteString.size(); i++) {
+            j += CODE_LENGTHS[byteString.getByte(i) & 255];
+        }
+        return (int) ((j + 7) >> 3);
+    }
+
+    public byte[] decode(byte[] bArr) {
+        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
+        Node node = this.root;
+        int i = 0;
+        int i2 = 0;
+        for (byte b : bArr) {
+            i = (i << 8) | (b & 255);
+            i2 += 8;
+            while (i2 >= 8) {
+                node = node.children[(i >>> (i2 - 8)) & 255];
+                if (node.children == null) {
+                    byteArrayOutputStream.write(node.symbol);
+                    i2 -= node.terminalBits;
+                    node = this.root;
+                } else {
+                    i2 -= 8;
+                }
+            }
+        }
+        while (i2 > 0) {
+            Node node2 = node.children[(i << (8 - i2)) & 255];
+            if (node2.children != null || node2.terminalBits > i2) {
+                break;
+            }
+            byteArrayOutputStream.write(node2.symbol);
+            i2 -= node2.terminalBits;
+            node = this.root;
+        }
+        return byteArrayOutputStream.toByteArray();
+    }
+
+    private void buildTree() {
+        int i = 0;
+        while (true) {
+            byte[] bArr = CODE_LENGTHS;
+            if (i >= bArr.length) {
+                return;
+            }
+            addCode(i, CODES[i], bArr[i]);
+            i++;
+        }
+    }
+
+    private void addCode(int i, int i2, byte b) {
+        Node node = new Node(i, b);
+        Node node2 = this.root;
+        while (b > 8) {
+            b = (byte) (b - 8);
+            int i3 = (i2 >>> b) & 255;
+            Node[] nodeArr = node2.children;
+            if (nodeArr == null) {
+                throw new IllegalStateException("invalid dictionary: prefix not unique");
+            }
+            if (nodeArr[i3] == null) {
+                nodeArr[i3] = new Node();
+            }
+            node2 = node2.children[i3];
+        }
+        int i4 = 8 - b;
+        int i5 = (i2 << i4) & 255;
+        int i6 = 1 << i4;
+        for (int i7 = i5; i7 < i5 + i6; i7++) {
+            node2.children[i7] = node;
+        }
+    }
+
+    public static final class Node {
+        final Node[] children;
+        final int symbol;
+        final int terminalBits;
+
+        public Node() {
+            this.children = new Node[256];
+            this.symbol = 0;
+            this.terminalBits = 0;
+        }
+
+        public Node(int i, int i2) {
+            this.children = null;
+            this.symbol = i;
+            int i3 = i2 & 7;
+            this.terminalBits = i3 == 0 ? 8 : i3;
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/thrid/okhttp/internal/http2/PushObserver.java

@@ -0,0 +1,38 @@
+package com.mbridge.msdk.thrid.okhttp.internal.http2;
+
+import com.mbridge.msdk.thrid.okio.BufferedSource;
+import java.io.IOException;
+import java.util.List;
+
+/* loaded from: classes4.dex */
+public interface PushObserver {
+    public static final PushObserver CANCEL = new PushObserver() { // from class: com.mbridge.msdk.thrid.okhttp.internal.http2.PushObserver.1
+        @Override // com.mbridge.msdk.thrid.okhttp.internal.http2.PushObserver
+        public boolean onHeaders(int i, List<Header> list, boolean z) {
+            return true;
+        }
+
+        @Override // com.mbridge.msdk.thrid.okhttp.internal.http2.PushObserver
+        public boolean onRequest(int i, List<Header> list) {
+            return true;
+        }
+
+        @Override // com.mbridge.msdk.thrid.okhttp.internal.http2.PushObserver
+        public void onReset(int i, ErrorCode errorCode) {
+        }
+
+        @Override // com.mbridge.msdk.thrid.okhttp.internal.http2.PushObserver
+        public boolean onData(int i, BufferedSource bufferedSource, int i2, boolean z) throws IOException {
+            bufferedSource.skip(i2);
+            return true;
+        }
+    };
+
+    boolean onData(int i, BufferedSource bufferedSource, int i2, boolean z) throws IOException;
+
+    boolean onHeaders(int i, List<Header> list, boolean z);
+
+    boolean onRequest(int i, List<Header> list);
+
+    void onReset(int i, ErrorCode errorCode);
+}

decompiled/sources/com/mbridge/msdk/thrid/okhttp/internal/http2/Settings.java

@@ -0,0 +1,90 @@
+package com.mbridge.msdk.thrid.okhttp.internal.http2;
+
+import java.util.Arrays;
+
+/* loaded from: classes4.dex */
+public final class Settings {
+    static final int COUNT = 10;
+    static final int DEFAULT_INITIAL_WINDOW_SIZE = 65535;
+    static final int ENABLE_PUSH = 2;
+    static final int HEADER_TABLE_SIZE = 1;
+    static final int INITIAL_WINDOW_SIZE = 7;
+    static final int MAX_CONCURRENT_STREAMS = 4;
+    static final int MAX_FRAME_SIZE = 5;
+    static final int MAX_HEADER_LIST_SIZE = 6;
+    private int set;
+    private final int[] values = new int[10];
+
+    public boolean isSet(int i) {
+        return ((1 << i) & this.set) != 0;
+    }
+
+    public void clear() {
+        this.set = 0;
+        Arrays.fill(this.values, 0);
+    }
+
+    public Settings set(int i, int i2) {
+        if (i >= 0) {
+            int[] iArr = this.values;
+            if (i < iArr.length) {
+                this.set = (1 << i) | this.set;
+                iArr[i] = i2;
+            }
+        }
+        return this;
+    }
+
+    public int get(int i) {
+        return this.values[i];
+    }
+
+    public int size() {
+        return Integer.bitCount(this.set);
+    }
+
+    public int getHeaderTableSize() {
+        if ((this.set & 2) != 0) {
+            return this.values[1];
+        }
+        return -1;
+    }
+
+    public boolean getEnablePush(boolean z) {
+        if ((this.set & 4) != 0) {
+            if (this.values[2] == 1) {
+                return true;
+            }
+        } else if (z) {
+            return true;
+        }
+        return false;
+    }
+
+    public int getMaxConcurrentStreams(int i) {
+        return (this.set & 16) != 0 ? this.values[4] : i;
+    }
+
+    public int getMaxFrameSize(int i) {
+        return (this.set & 32) != 0 ? this.values[5] : i;
+    }
+
+    public int getMaxHeaderListSize(int i) {
+        return (this.set & 64) != 0 ? this.values[6] : i;
+    }
+
+    public int getInitialWindowSize() {
+        if ((this.set & 128) != 0) {
+            return this.values[7];
+        }
+        return 65535;
+    }
+
+    public void merge(Settings settings) {
+        for (int i = 0; i < 10; i++) {
+            if (settings.isSet(i)) {
+                set(i, settings.get(i));
+            }
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/thrid/okhttp/internal/http2/StreamResetException.java

@@ -0,0 +1,13 @@
+package com.mbridge.msdk.thrid.okhttp.internal.http2;
+
+import java.io.IOException;
+
+/* loaded from: classes4.dex */
+public final class StreamResetException extends IOException {
+    public final ErrorCode errorCode;
+
+    public StreamResetException(ErrorCode errorCode) {
+        super("stream was reset: " + errorCode);
+        this.errorCode = errorCode;
+    }
+}

decompiled/sources/com/mbridge/msdk/thrid/okhttp/internal/io/FileSystem.java

@@ -0,0 +1,97 @@
+package com.mbridge.msdk.thrid.okhttp.internal.io;
+
+import com.mbridge.msdk.thrid.okio.Okio;
+import com.mbridge.msdk.thrid.okio.Sink;
+import com.mbridge.msdk.thrid.okio.Source;
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+
+/* loaded from: classes4.dex */
+public interface FileSystem {
+    public static final FileSystem SYSTEM = new FileSystem() { // from class: com.mbridge.msdk.thrid.okhttp.internal.io.FileSystem.1
+        @Override // com.mbridge.msdk.thrid.okhttp.internal.io.FileSystem
+        public Source source(File file) throws FileNotFoundException {
+            return Okio.source(file);
+        }
+
+        @Override // com.mbridge.msdk.thrid.okhttp.internal.io.FileSystem
+        public Sink sink(File file) throws FileNotFoundException {
+            try {
+                return Okio.sink(file);
+            } catch (FileNotFoundException unused) {
+                file.getParentFile().mkdirs();
+                return Okio.sink(file);
+            }
+        }
+
+        @Override // com.mbridge.msdk.thrid.okhttp.internal.io.FileSystem
+        public Sink appendingSink(File file) throws FileNotFoundException {
+            try {
+                return Okio.appendingSink(file);
+            } catch (FileNotFoundException unused) {
+                file.getParentFile().mkdirs();
+                return Okio.appendingSink(file);
+            }
+        }
+
+        @Override // com.mbridge.msdk.thrid.okhttp.internal.io.FileSystem
+        public void delete(File file) throws IOException {
+            if (file.delete() || !file.exists()) {
+                return;
+            }
+            throw new IOException("failed to delete " + file);
+        }
+
+        @Override // com.mbridge.msdk.thrid.okhttp.internal.io.FileSystem
+        public boolean exists(File file) {
+            return file.exists();
+        }
+
+        @Override // com.mbridge.msdk.thrid.okhttp.internal.io.FileSystem
+        public long size(File file) {
+            return file.length();
+        }
+
+        @Override // com.mbridge.msdk.thrid.okhttp.internal.io.FileSystem
+        public void rename(File file, File file2) throws IOException {
+            delete(file2);
+            if (file.renameTo(file2)) {
+                return;
+            }
+            throw new IOException("failed to rename " + file + " to " + file2);
+        }
+
+        @Override // com.mbridge.msdk.thrid.okhttp.internal.io.FileSystem
+        public void deleteContents(File file) throws IOException {
+            File[] listFiles = file.listFiles();
+            if (listFiles == null) {
+                throw new IOException("not a readable directory: " + file);
+            }
+            for (File file2 : listFiles) {
+                if (file2.isDirectory()) {
+                    deleteContents(file2);
+                }
+                if (!file2.delete()) {
+                    throw new IOException("failed to delete " + file2);
+                }
+            }
+        }
+    };
+
+    Sink appendingSink(File file) throws FileNotFoundException;
+
+    void delete(File file) throws IOException;
+
+    void deleteContents(File file) throws IOException;
+
+    boolean exists(File file);
+
+    void rename(File file, File file2) throws IOException;
+
+    Sink sink(File file) throws FileNotFoundException;
+
+    long size(File file);
+
+    Source source(File file) throws FileNotFoundException;
+}

decompiled/sources/com/mbridge/msdk/thrid/okhttp/internal/platform/Android10Platform$$ExternalSyntheticApiModelOutline0.java

@@ -0,0 +1,5 @@
+package com.mbridge.msdk.thrid.okhttp.internal.platform;
+
+/* loaded from: classes4.dex */
+public abstract /* synthetic */ class Android10Platform$$ExternalSyntheticApiModelOutline0 {
+}

decompiled/sources/com/mbridge/msdk/thrid/okhttp/internal/platform/Android10Platform$$ExternalSyntheticApiModelOutline1.java

@@ -0,0 +1,5 @@
+package com.mbridge.msdk.thrid.okhttp.internal.platform;
+
+/* loaded from: classes4.dex */
+public abstract /* synthetic */ class Android10Platform$$ExternalSyntheticApiModelOutline1 {
+}

decompiled/sources/com/mbridge/msdk/thrid/okhttp/internal/platform/Android10Platform$$ExternalSyntheticApiModelOutline2.java

@@ -0,0 +1,5 @@
+package com.mbridge.msdk.thrid.okhttp.internal.platform;
+
+/* loaded from: classes4.dex */
+public abstract /* synthetic */ class Android10Platform$$ExternalSyntheticApiModelOutline2 {
+}

decompiled/sources/com/mbridge/msdk/thrid/okhttp/internal/platform/Android10Platform$$ExternalSyntheticApiModelOutline3.java

@@ -0,0 +1,5 @@
+package com.mbridge.msdk.thrid.okhttp.internal.platform;
+
+/* loaded from: classes4.dex */
+public abstract /* synthetic */ class Android10Platform$$ExternalSyntheticApiModelOutline3 {
+}

decompiled/sources/com/mbridge/msdk/thrid/okhttp/internal/platform/Android10Platform.java

@@ -0,0 +1,61 @@
+package com.mbridge.msdk.thrid.okhttp.internal.platform;
+
+import android.annotation.SuppressLint;
+import android.net.ssl.SSLSockets;
+import com.mbridge.msdk.thrid.okhttp.Protocol;
+import java.io.IOException;
+import java.util.List;
+import javax.net.ssl.SSLParameters;
+import javax.net.ssl.SSLSocket;
+
+@SuppressLint({"NewApi"})
+/* loaded from: classes4.dex */
+class Android10Platform extends AndroidPlatform {
+    public Android10Platform(Class<?> cls) {
+        super(cls, null, null, null, null);
+    }
+
+    @Override // com.mbridge.msdk.thrid.okhttp.internal.platform.AndroidPlatform, com.mbridge.msdk.thrid.okhttp.internal.platform.Platform
+    @SuppressLint({"NewApi"})
+    public void configureTlsExtensions(SSLSocket sSLSocket, String str, List<Protocol> list) throws IOException {
+        try {
+            enableSessionTickets(sSLSocket);
+            SSLParameters sSLParameters = sSLSocket.getSSLParameters();
+            sSLParameters.setApplicationProtocols((String[]) Platform.alpnProtocolNames(list).toArray(new String[0]));
+            sSLSocket.setSSLParameters(sSLParameters);
+        } catch (IllegalArgumentException e) {
+            throw new IOException("Android internal error", e);
+        }
+    }
+
+    private void enableSessionTickets(SSLSocket sSLSocket) {
+        boolean isSupportedSocket;
+        isSupportedSocket = SSLSockets.isSupportedSocket(sSLSocket);
+        if (isSupportedSocket) {
+            SSLSockets.setUseSessionTickets(sSLSocket, true);
+        }
+    }
+
+    @Override // com.mbridge.msdk.thrid.okhttp.internal.platform.AndroidPlatform, com.mbridge.msdk.thrid.okhttp.internal.platform.Platform
+    public String getSelectedProtocol(SSLSocket sSLSocket) {
+        String applicationProtocol;
+        applicationProtocol = sSLSocket.getApplicationProtocol();
+        if (applicationProtocol == null || applicationProtocol.isEmpty()) {
+            return null;
+        }
+        return applicationProtocol;
+    }
+
+    public static Platform buildIfSupported() {
+        if (!Platform.isAndroid()) {
+            return null;
+        }
+        try {
+            if (AndroidPlatform.getSdkInt() >= 29) {
+                return new Android10Platform(Class.forName("com.android.org.conscrypt.SSLParametersImpl"));
+            }
+        } catch (ClassNotFoundException unused) {
+        }
+        return null;
+    }
+}

decompiled/sources/com/mbridge/msdk/thrid/okhttp/internal/platform/AndroidPlatform.java

@@ -0,0 +1,384 @@
+package com.mbridge.msdk.thrid.okhttp.internal.platform;
+
+import android.os.Build;
+import android.util.Log;
+import com.mbridge.msdk.thrid.okhttp.Protocol;
+import com.mbridge.msdk.thrid.okhttp.internal.Util;
+import com.mbridge.msdk.thrid.okhttp.internal.tls.CertificateChainCleaner;
+import com.mbridge.msdk.thrid.okhttp.internal.tls.TrustRootIndex;
+import com.vungle.ads.internal.presenter.MRAIDPresenter;
+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.Security;
+import java.security.cert.Certificate;
+import java.security.cert.TrustAnchor;
+import java.security.cert.X509Certificate;
+import java.util.List;
+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;
+
+/* loaded from: classes4.dex */
+class AndroidPlatform extends Platform {
+    private static final int MAX_LOG_LENGTH = 4000;
+    private final CloseGuard closeGuard = CloseGuard.get();
+    private final OptionalMethod<Socket> getAlpnSelectedProtocol;
+    private final OptionalMethod<Socket> setAlpnProtocols;
+    private final OptionalMethod<Socket> setHostname;
+    private final OptionalMethod<Socket> setUseSessionTickets;
+    private final Class<?> sslParametersClass;
+
+    public static int getSdkInt() {
+        try {
+            return Build.VERSION.SDK_INT;
+        } catch (NoClassDefFoundError unused) {
+            return 0;
+        }
+    }
+
+    public AndroidPlatform(Class<?> cls, OptionalMethod<Socket> optionalMethod, OptionalMethod<Socket> optionalMethod2, OptionalMethod<Socket> optionalMethod3, OptionalMethod<Socket> optionalMethod4) {
+        this.sslParametersClass = cls;
+        this.setUseSessionTickets = optionalMethod;
+        this.setHostname = optionalMethod2;
+        this.getAlpnSelectedProtocol = optionalMethod3;
+        this.setAlpnProtocols = optionalMethod4;
+    }
+
+    @Override // com.mbridge.msdk.thrid.okhttp.internal.platform.Platform
+    public void connectSocket(Socket socket, InetSocketAddress inetSocketAddress, int i) throws IOException {
+        try {
+            socket.connect(inetSocketAddress, i);
+        } catch (AssertionError e) {
+            if (!Util.isAndroidGetsocknameError(e)) {
+                throw e;
+            }
+            throw new IOException(e);
+        } catch (ClassCastException e2) {
+            if (Build.VERSION.SDK_INT == 26) {
+                IOException iOException = new IOException("Exception in connect");
+                iOException.initCause(e2);
+                throw iOException;
+            }
+            throw e2;
+        } catch (SecurityException e3) {
+            IOException iOException2 = new IOException("Exception in connect");
+            iOException2.initCause(e3);
+            throw iOException2;
+        }
+    }
+
+    @Override // com.mbridge.msdk.thrid.okhttp.internal.platform.Platform
+    public X509TrustManager trustManager(SSLSocketFactory sSLSocketFactory) {
+        Object readFieldOrNull = Platform.readFieldOrNull(sSLSocketFactory, this.sslParametersClass, "sslParameters");
+        if (readFieldOrNull == null) {
+            try {
+                readFieldOrNull = Platform.readFieldOrNull(sSLSocketFactory, Class.forName("com.google.android.gms.org.conscrypt.SSLParametersImpl", false, sSLSocketFactory.getClass().getClassLoader()), "sslParameters");
+            } catch (ClassNotFoundException unused) {
+                return super.trustManager(sSLSocketFactory);
+            }
+        }
+        X509TrustManager x509TrustManager = (X509TrustManager) Platform.readFieldOrNull(readFieldOrNull, X509TrustManager.class, "x509TrustManager");
+        return x509TrustManager != null ? x509TrustManager : (X509TrustManager) Platform.readFieldOrNull(readFieldOrNull, X509TrustManager.class, "trustManager");
+    }
+
+    @Override // com.mbridge.msdk.thrid.okhttp.internal.platform.Platform
+    public void configureTlsExtensions(SSLSocket sSLSocket, String str, List<Protocol> list) throws IOException {
+        if (str != null) {
+            this.setUseSessionTickets.invokeOptionalWithoutCheckedException(sSLSocket, Boolean.TRUE);
+            this.setHostname.invokeOptionalWithoutCheckedException(sSLSocket, str);
+        }
+        OptionalMethod<Socket> optionalMethod = this.setAlpnProtocols;
+        if (optionalMethod == null || !optionalMethod.isSupported(sSLSocket)) {
+            return;
+        }
+        this.setAlpnProtocols.invokeWithoutCheckedException(sSLSocket, Platform.concatLengthPrefixed(list));
+    }
+
+    @Override // com.mbridge.msdk.thrid.okhttp.internal.platform.Platform
+    public String getSelectedProtocol(SSLSocket sSLSocket) {
+        byte[] bArr;
+        OptionalMethod<Socket> optionalMethod = this.getAlpnSelectedProtocol;
+        if (optionalMethod == null || !optionalMethod.isSupported(sSLSocket) || (bArr = (byte[]) this.getAlpnSelectedProtocol.invokeWithoutCheckedException(sSLSocket, new Object[0])) == null) {
+            return null;
+        }
+        return new String(bArr, Util.UTF_8);
+    }
+
+    @Override // com.mbridge.msdk.thrid.okhttp.internal.platform.Platform
+    public void log(int i, String str, Throwable th) {
+        int min;
+        int i2 = i != 5 ? 3 : 5;
+        if (th != null) {
+            str = str + '\n' + Log.getStackTraceString(th);
+        }
+        int length = str.length();
+        int i3 = 0;
+        while (i3 < length) {
+            int indexOf = str.indexOf(10, i3);
+            if (indexOf == -1) {
+                indexOf = length;
+            }
+            while (true) {
+                min = Math.min(indexOf, i3 + MAX_LOG_LENGTH);
+                Log.println(i2, "OkHttp", str.substring(i3, min));
+                if (min >= indexOf) {
+                    break;
+                } else {
+                    i3 = min;
+                }
+            }
+            i3 = min + 1;
+        }
+    }
+
+    @Override // com.mbridge.msdk.thrid.okhttp.internal.platform.Platform
+    public Object getStackTraceForCloseable(String str) {
+        return this.closeGuard.createAndOpen(str);
+    }
+
+    @Override // com.mbridge.msdk.thrid.okhttp.internal.platform.Platform
+    public void logCloseableLeak(String str, Object obj) {
+        if (this.closeGuard.warnIfOpen(obj)) {
+            return;
+        }
+        log(5, str, null);
+    }
+
+    @Override // com.mbridge.msdk.thrid.okhttp.internal.platform.Platform
+    public boolean isCleartextTrafficPermitted(String str) {
+        try {
+            Class<?> cls = Class.forName("android.security.NetworkSecurityPolicy");
+            return api24IsCleartextTrafficPermitted(str, cls, cls.getMethod("getInstance", new Class[0]).invoke(null, new Object[0]));
+        } catch (ClassNotFoundException | NoSuchMethodException unused) {
+            return super.isCleartextTrafficPermitted(str);
+        } catch (IllegalAccessException e) {
+            e = e;
+            throw Util.assertionError("unable to determine cleartext support", e);
+        } catch (IllegalArgumentException e2) {
+            e = e2;
+            throw Util.assertionError("unable to determine cleartext support", e);
+        } catch (InvocationTargetException e3) {
+            e = e3;
+            throw Util.assertionError("unable to determine cleartext support", e);
+        }
+    }
+
+    private boolean api24IsCleartextTrafficPermitted(String str, Class<?> cls, Object obj) throws InvocationTargetException, IllegalAccessException {
+        try {
+            return ((Boolean) cls.getMethod("isCleartextTrafficPermitted", String.class).invoke(obj, str)).booleanValue();
+        } catch (NoSuchMethodException unused) {
+            return api23IsCleartextTrafficPermitted(str, cls, obj);
+        }
+    }
+
+    private boolean api23IsCleartextTrafficPermitted(String str, Class<?> cls, Object obj) throws InvocationTargetException, IllegalAccessException {
+        try {
+            return ((Boolean) cls.getMethod("isCleartextTrafficPermitted", new Class[0]).invoke(obj, new Object[0])).booleanValue();
+        } catch (NoSuchMethodException unused) {
+            return super.isCleartextTrafficPermitted(str);
+        }
+    }
+
+    private static boolean supportsAlpn() {
+        if (Security.getProvider("GMSCore_OpenSSL") != null) {
+            return true;
+        }
+        try {
+            Class.forName("android.net.Network");
+            return true;
+        } catch (ClassNotFoundException unused) {
+            return false;
+        }
+    }
+
+    @Override // com.mbridge.msdk.thrid.okhttp.internal.platform.Platform
+    public CertificateChainCleaner buildCertificateChainCleaner(X509TrustManager x509TrustManager) {
+        try {
+            Class<?> cls = Class.forName("android.net.http.X509TrustManagerExtensions");
+            return new AndroidCertificateChainCleaner(cls.getConstructor(X509TrustManager.class).newInstance(x509TrustManager), cls.getMethod("checkServerTrusted", X509Certificate[].class, String.class, String.class));
+        } catch (Exception unused) {
+            return super.buildCertificateChainCleaner(x509TrustManager);
+        }
+    }
+
+    public static Platform buildIfSupported() {
+        Class<?> cls;
+        OptionalMethod optionalMethod;
+        OptionalMethod optionalMethod2;
+        if (!Platform.isAndroid()) {
+            return null;
+        }
+        try {
+            try {
+                cls = Class.forName("com.android.org.conscrypt.SSLParametersImpl");
+            } catch (ClassNotFoundException unused) {
+                cls = Class.forName("org.apache.harmony.xnet.provider.jsse.SSLParametersImpl");
+            }
+            Class<?> cls2 = cls;
+            OptionalMethod optionalMethod3 = new OptionalMethod(null, "setUseSessionTickets", Boolean.TYPE);
+            OptionalMethod optionalMethod4 = new OptionalMethod(null, "setHostname", String.class);
+            if (supportsAlpn()) {
+                OptionalMethod optionalMethod5 = new OptionalMethod(byte[].class, "getAlpnSelectedProtocol", new Class[0]);
+                optionalMethod2 = new OptionalMethod(null, "setAlpnProtocols", byte[].class);
+                optionalMethod = optionalMethod5;
+            } else {
+                optionalMethod = null;
+                optionalMethod2 = null;
+            }
+            return new AndroidPlatform(cls2, optionalMethod3, optionalMethod4, optionalMethod, optionalMethod2);
+        } catch (ClassNotFoundException unused2) {
+            return null;
+        }
+    }
+
+    @Override // com.mbridge.msdk.thrid.okhttp.internal.platform.Platform
+    public TrustRootIndex buildTrustRootIndex(X509TrustManager x509TrustManager) {
+        try {
+            Method declaredMethod = x509TrustManager.getClass().getDeclaredMethod("findTrustAnchorByIssuerAndSignature", X509Certificate.class);
+            declaredMethod.setAccessible(true);
+            return new AndroidTrustRootIndex(x509TrustManager, declaredMethod);
+        } catch (NoSuchMethodException unused) {
+            return super.buildTrustRootIndex(x509TrustManager);
+        }
+    }
+
+    public static final class AndroidCertificateChainCleaner extends CertificateChainCleaner {
+        private final Method checkServerTrusted;
+        private final Object x509TrustManagerExtensions;
+
+        public int hashCode() {
+            return 0;
+        }
+
+        public AndroidCertificateChainCleaner(Object obj, Method method) {
+            this.x509TrustManagerExtensions = obj;
+            this.checkServerTrusted = method;
+        }
+
+        @Override // com.mbridge.msdk.thrid.okhttp.internal.tls.CertificateChainCleaner
+        public List<Certificate> clean(List<Certificate> list, String str) throws SSLPeerUnverifiedException {
+            try {
+                return (List) this.checkServerTrusted.invoke(this.x509TrustManagerExtensions, (X509Certificate[]) list.toArray(new X509Certificate[list.size()]), "RSA", str);
+            } catch (IllegalAccessException e) {
+                throw new AssertionError(e);
+            } catch (InvocationTargetException e2) {
+                SSLPeerUnverifiedException sSLPeerUnverifiedException = new SSLPeerUnverifiedException(e2.getMessage());
+                sSLPeerUnverifiedException.initCause(e2);
+                throw sSLPeerUnverifiedException;
+            }
+        }
+
+        public boolean equals(Object obj) {
+            return obj instanceof AndroidCertificateChainCleaner;
+        }
+    }
+
+    public static final class CloseGuard {
+        private final Method getMethod;
+        private final Method openMethod;
+        private final Method warnIfOpenMethod;
+
+        public CloseGuard(Method method, Method method2, Method method3) {
+            this.getMethod = method;
+            this.openMethod = method2;
+            this.warnIfOpenMethod = method3;
+        }
+
+        public Object createAndOpen(String str) {
+            Method method = this.getMethod;
+            if (method != null) {
+                try {
+                    Object invoke = method.invoke(null, new Object[0]);
+                    this.openMethod.invoke(invoke, str);
+                    return invoke;
+                } catch (Exception unused) {
+                }
+            }
+            return null;
+        }
+
+        public boolean warnIfOpen(Object obj) {
+            if (obj == null) {
+                return false;
+            }
+            try {
+                this.warnIfOpenMethod.invoke(obj, new Object[0]);
+                return true;
+            } catch (Exception unused) {
+                return false;
+            }
+        }
+
+        public static CloseGuard get() {
+            Method method;
+            Method method2;
+            Method method3;
+            try {
+                Class<?> cls = Class.forName("dalvik.system.CloseGuard");
+                method = cls.getMethod("get", new Class[0]);
+                method3 = cls.getMethod(MRAIDPresenter.OPEN, String.class);
+                method2 = cls.getMethod("warnIfOpen", new Class[0]);
+            } catch (Exception unused) {
+                method = null;
+                method2 = null;
+                method3 = null;
+            }
+            return new CloseGuard(method, method3, method2);
+        }
+    }
+
+    public static final class AndroidTrustRootIndex implements TrustRootIndex {
+        private final Method findByIssuerAndSignatureMethod;
+        private final X509TrustManager trustManager;
+
+        public AndroidTrustRootIndex(X509TrustManager x509TrustManager, Method method) {
+            this.findByIssuerAndSignatureMethod = method;
+            this.trustManager = x509TrustManager;
+        }
+
+        @Override // com.mbridge.msdk.thrid.okhttp.internal.tls.TrustRootIndex
+        public X509Certificate findByIssuerAndSignature(X509Certificate x509Certificate) {
+            try {
+                TrustAnchor trustAnchor = (TrustAnchor) this.findByIssuerAndSignatureMethod.invoke(this.trustManager, x509Certificate);
+                if (trustAnchor != null) {
+                    return trustAnchor.getTrustedCert();
+                }
+                return null;
+            } catch (IllegalAccessException e) {
+                throw Util.assertionError("unable to get issues and signature", e);
+            } catch (InvocationTargetException unused) {
+                return null;
+            }
+        }
+
+        public boolean equals(Object obj) {
+            if (obj == this) {
+                return true;
+            }
+            if (!(obj instanceof AndroidTrustRootIndex)) {
+                return false;
+            }
+            AndroidTrustRootIndex androidTrustRootIndex = (AndroidTrustRootIndex) obj;
+            return this.trustManager.equals(androidTrustRootIndex.trustManager) && this.findByIssuerAndSignatureMethod.equals(androidTrustRootIndex.findByIssuerAndSignatureMethod);
+        }
+
+        public int hashCode() {
+            return this.trustManager.hashCode() + (this.findByIssuerAndSignatureMethod.hashCode() * 31);
+        }
+    }
+
+    @Override // com.mbridge.msdk.thrid.okhttp.internal.platform.Platform
+    public SSLContext getSSLContext() {
+        try {
+            return SSLContext.getInstance("TLS");
+        } catch (NoSuchAlgorithmException e) {
+            throw new IllegalStateException("No TLS provider", e);
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/thrid/okhttp/internal/platform/ConscryptPlatform.java

@@ -0,0 +1,91 @@
+package com.mbridge.msdk.thrid.okhttp.internal.platform;
+
+import com.mbridge.msdk.thrid.okhttp.Protocol;
+import java.io.IOException;
+import java.security.NoSuchAlgorithmException;
+import java.security.Provider;
+import java.util.List;
+import javax.net.ssl.SSLContext;
+import javax.net.ssl.SSLSocket;
+import javax.net.ssl.SSLSocketFactory;
+import javax.net.ssl.X509TrustManager;
+import org.conscrypt.Conscrypt;
+
+/* loaded from: classes4.dex */
+public class ConscryptPlatform extends Platform {
+    private ConscryptPlatform() {
+    }
+
+    private Provider getProvider() {
+        return Conscrypt.newProviderBuilder().provideTrustManager().build();
+    }
+
+    @Override // com.mbridge.msdk.thrid.okhttp.internal.platform.Platform
+    public X509TrustManager trustManager(SSLSocketFactory sSLSocketFactory) {
+        if (!Conscrypt.isConscrypt(sSLSocketFactory)) {
+            return super.trustManager(sSLSocketFactory);
+        }
+        try {
+            Object readFieldOrNull = Platform.readFieldOrNull(sSLSocketFactory, Object.class, "sslParameters");
+            if (readFieldOrNull != null) {
+                return (X509TrustManager) Platform.readFieldOrNull(readFieldOrNull, X509TrustManager.class, "x509TrustManager");
+            }
+            return null;
+        } catch (Exception e) {
+            throw new UnsupportedOperationException("clientBuilder.sslSocketFactory(SSLSocketFactory) not supported on Conscrypt", e);
+        }
+    }
+
+    @Override // com.mbridge.msdk.thrid.okhttp.internal.platform.Platform
+    public void configureTlsExtensions(SSLSocket sSLSocket, String str, List<Protocol> list) throws IOException {
+        if (Conscrypt.isConscrypt(sSLSocket)) {
+            if (str != null) {
+                Conscrypt.setUseSessionTickets(sSLSocket, true);
+                Conscrypt.setHostname(sSLSocket, str);
+            }
+            Conscrypt.setApplicationProtocols(sSLSocket, (String[]) Platform.alpnProtocolNames(list).toArray(new String[0]));
+            return;
+        }
+        super.configureTlsExtensions(sSLSocket, str, list);
+    }
+
+    @Override // com.mbridge.msdk.thrid.okhttp.internal.platform.Platform
+    public String getSelectedProtocol(SSLSocket sSLSocket) {
+        if (Conscrypt.isConscrypt(sSLSocket)) {
+            return Conscrypt.getApplicationProtocol(sSLSocket);
+        }
+        return super.getSelectedProtocol(sSLSocket);
+    }
+
+    @Override // com.mbridge.msdk.thrid.okhttp.internal.platform.Platform
+    public SSLContext getSSLContext() {
+        try {
+            return SSLContext.getInstance("TLSv1.3", getProvider());
+        } catch (NoSuchAlgorithmException e) {
+            try {
+                return SSLContext.getInstance("TLS", getProvider());
+            } catch (NoSuchAlgorithmException unused) {
+                throw new IllegalStateException("No TLS provider", e);
+            }
+        }
+    }
+
+    public static ConscryptPlatform buildIfSupported() {
+        try {
+            Class.forName("org.conscrypt.Conscrypt");
+            if (Conscrypt.isAvailable()) {
+                return new ConscryptPlatform();
+            }
+            return null;
+        } catch (ClassNotFoundException unused) {
+            return null;
+        }
+    }
+
+    @Override // com.mbridge.msdk.thrid.okhttp.internal.platform.Platform
+    public void configureSslSocketFactory(SSLSocketFactory sSLSocketFactory) {
+        if (Conscrypt.isConscrypt(sSLSocketFactory)) {
+            Conscrypt.setUseEngineSocket(sSLSocketFactory, true);
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/thrid/okhttp/internal/platform/Jdk9Platform.java

@@ -0,0 +1,67 @@
+package com.mbridge.msdk.thrid.okhttp.internal.platform;
+
+import com.mbridge.msdk.thrid.okhttp.Protocol;
+import com.mbridge.msdk.thrid.okhttp.internal.Util;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.List;
+import javax.net.ssl.SSLParameters;
+import javax.net.ssl.SSLSocket;
+import javax.net.ssl.SSLSocketFactory;
+import javax.net.ssl.X509TrustManager;
+
+/* loaded from: classes4.dex */
+final class Jdk9Platform extends Platform {
+    final Method getProtocolMethod;
+    final Method setProtocolMethod;
+
+    public Jdk9Platform(Method method, Method method2) {
+        this.setProtocolMethod = method;
+        this.getProtocolMethod = method2;
+    }
+
+    @Override // com.mbridge.msdk.thrid.okhttp.internal.platform.Platform
+    public void configureTlsExtensions(SSLSocket sSLSocket, String str, List<Protocol> list) {
+        try {
+            SSLParameters sSLParameters = sSLSocket.getSSLParameters();
+            List<String> alpnProtocolNames = Platform.alpnProtocolNames(list);
+            this.setProtocolMethod.invoke(sSLParameters, alpnProtocolNames.toArray(new String[alpnProtocolNames.size()]));
+            sSLSocket.setSSLParameters(sSLParameters);
+        } catch (IllegalAccessException | InvocationTargetException e) {
+            throw Util.assertionError("unable to set ssl parameters", e);
+        }
+    }
+
+    @Override // com.mbridge.msdk.thrid.okhttp.internal.platform.Platform
+    public String getSelectedProtocol(SSLSocket sSLSocket) {
+        try {
+            String str = (String) this.getProtocolMethod.invoke(sSLSocket, new Object[0]);
+            if (str != null) {
+                if (!str.equals("")) {
+                    return str;
+                }
+            }
+            return null;
+        } catch (IllegalAccessException e) {
+            throw Util.assertionError("failed to get ALPN selected protocol", e);
+        } catch (InvocationTargetException e2) {
+            if (e2.getCause() instanceof UnsupportedOperationException) {
+                return null;
+            }
+            throw Util.assertionError("failed to get ALPN selected protocol", e2);
+        }
+    }
+
+    @Override // com.mbridge.msdk.thrid.okhttp.internal.platform.Platform
+    public X509TrustManager trustManager(SSLSocketFactory sSLSocketFactory) {
+        throw new UnsupportedOperationException("clientBuilder.sslSocketFactory(SSLSocketFactory) not supported on JDK 9+");
+    }
+
+    public static Jdk9Platform buildIfSupported() {
+        try {
+            return new Jdk9Platform(SSLParameters.class.getMethod("setApplicationProtocols", String[].class), SSLSocket.class.getMethod("getApplicationProtocol", new Class[0]));
+        } catch (NoSuchMethodException unused) {
+            return null;
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/thrid/okhttp/internal/platform/JdkWithJettyBootPlatform.java

@@ -0,0 +1,129 @@
+package com.mbridge.msdk.thrid.okhttp.internal.platform;
+
+import com.mbridge.msdk.thrid.okhttp.Protocol;
+import com.mbridge.msdk.thrid.okhttp.internal.Util;
+import csdk.gluads.Consts;
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.lang.reflect.Proxy;
+import java.util.List;
+import javax.net.ssl.SSLSocket;
+
+/* loaded from: classes4.dex */
+class JdkWithJettyBootPlatform extends Platform {
+    private final Class<?> clientProviderClass;
+    private final Method getMethod;
+    private final Method putMethod;
+    private final Method removeMethod;
+    private final Class<?> serverProviderClass;
+
+    public JdkWithJettyBootPlatform(Method method, Method method2, Method method3, Class<?> cls, Class<?> cls2) {
+        this.putMethod = method;
+        this.getMethod = method2;
+        this.removeMethod = method3;
+        this.clientProviderClass = cls;
+        this.serverProviderClass = cls2;
+    }
+
+    @Override // com.mbridge.msdk.thrid.okhttp.internal.platform.Platform
+    public void configureTlsExtensions(SSLSocket sSLSocket, String str, List<Protocol> list) {
+        try {
+            this.putMethod.invoke(null, sSLSocket, Proxy.newProxyInstance(Platform.class.getClassLoader(), new Class[]{this.clientProviderClass, this.serverProviderClass}, new JettyNegoProvider(Platform.alpnProtocolNames(list))));
+        } catch (IllegalAccessException | InvocationTargetException e) {
+            throw Util.assertionError("unable to set alpn", e);
+        }
+    }
+
+    @Override // com.mbridge.msdk.thrid.okhttp.internal.platform.Platform
+    public void afterHandshake(SSLSocket sSLSocket) {
+        try {
+            this.removeMethod.invoke(null, sSLSocket);
+        } catch (IllegalAccessException | InvocationTargetException e) {
+            throw Util.assertionError("unable to remove alpn", e);
+        }
+    }
+
+    @Override // com.mbridge.msdk.thrid.okhttp.internal.platform.Platform
+    public String getSelectedProtocol(SSLSocket sSLSocket) {
+        try {
+            JettyNegoProvider jettyNegoProvider = (JettyNegoProvider) Proxy.getInvocationHandler(this.getMethod.invoke(null, sSLSocket));
+            boolean z = jettyNegoProvider.unsupported;
+            if (!z && jettyNegoProvider.selected == null) {
+                Platform.get().log(4, "ALPN callback dropped: HTTP/2 is disabled. Is alpn-boot on the boot class path?", null);
+                return null;
+            }
+            if (z) {
+                return null;
+            }
+            return jettyNegoProvider.selected;
+        } catch (IllegalAccessException e) {
+            e = e;
+            throw Util.assertionError("unable to get selected protocol", e);
+        } catch (InvocationTargetException e2) {
+            e = e2;
+            throw Util.assertionError("unable to get selected protocol", e);
+        }
+    }
+
+    public static Platform buildIfSupported() {
+        try {
+            Class<?> cls = Class.forName("org.eclipse.jetty.alpn.ALPN");
+            Class<?> cls2 = Class.forName("org.eclipse.jetty.alpn.ALPN$Provider");
+            return new JdkWithJettyBootPlatform(cls.getMethod("put", SSLSocket.class, cls2), cls.getMethod("get", SSLSocket.class), cls.getMethod("remove", SSLSocket.class), Class.forName("org.eclipse.jetty.alpn.ALPN$ClientProvider"), Class.forName("org.eclipse.jetty.alpn.ALPN$ServerProvider"));
+        } catch (ClassNotFoundException | NoSuchMethodException unused) {
+            return null;
+        }
+    }
+
+    public static class JettyNegoProvider implements InvocationHandler {
+        private final List<String> protocols;
+        String selected;
+        boolean unsupported;
+
+        public JettyNegoProvider(List<String> list) {
+            this.protocols = list;
+        }
+
+        @Override // java.lang.reflect.InvocationHandler
+        public Object invoke(Object obj, Method method, Object[] objArr) throws Throwable {
+            String name = method.getName();
+            Class<?> returnType = method.getReturnType();
+            if (objArr == null) {
+                objArr = Util.EMPTY_STRING_ARRAY;
+            }
+            if (name.equals("supports") && Boolean.TYPE == returnType) {
+                return Boolean.TRUE;
+            }
+            if (name.equals(Consts.SDK_PRIVACY_STAGE_UNSUPPORTED) && Void.TYPE == returnType) {
+                this.unsupported = true;
+                return null;
+            }
+            if (name.equals("protocols") && objArr.length == 0) {
+                return this.protocols;
+            }
+            if ((name.equals("selectProtocol") || name.equals("select")) && String.class == returnType && objArr.length == 1) {
+                Object obj2 = objArr[0];
+                if (obj2 instanceof List) {
+                    List list = (List) obj2;
+                    int size = list.size();
+                    for (int i = 0; i < size; i++) {
+                        if (this.protocols.contains(list.get(i))) {
+                            String str = (String) list.get(i);
+                            this.selected = str;
+                            return str;
+                        }
+                    }
+                    String str2 = this.protocols.get(0);
+                    this.selected = str2;
+                    return str2;
+                }
+            }
+            if ((name.equals("protocolSelected") || name.equals("selected")) && objArr.length == 1) {
+                this.selected = (String) objArr[0];
+                return null;
+            }
+            return method.invoke(this, objArr);
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/thrid/okhttp/internal/platform/OptionalMethod.java

@@ -0,0 +1,103 @@
+package com.mbridge.msdk.thrid.okhttp.internal.platform;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+
+/* loaded from: classes4.dex */
+class OptionalMethod<T> {
+    private final String methodName;
+    private final Class[] methodParams;
+    private final Class<?> returnType;
+
+    public OptionalMethod(Class<?> cls, String str, Class... clsArr) {
+        this.returnType = cls;
+        this.methodName = str;
+        this.methodParams = clsArr;
+    }
+
+    public boolean isSupported(T t) {
+        return getMethod(t.getClass()) != null;
+    }
+
+    public Object invokeOptional(T t, Object... objArr) throws InvocationTargetException {
+        Method method = getMethod(t.getClass());
+        if (method == null) {
+            return null;
+        }
+        try {
+            return method.invoke(t, objArr);
+        } catch (IllegalAccessException unused) {
+            return null;
+        }
+    }
+
+    public Object invokeOptionalWithoutCheckedException(T t, Object... objArr) {
+        try {
+            return invokeOptional(t, objArr);
+        } catch (InvocationTargetException e) {
+            Throwable targetException = e.getTargetException();
+            if (targetException instanceof RuntimeException) {
+                throw ((RuntimeException) targetException);
+            }
+            AssertionError assertionError = new AssertionError("Unexpected exception");
+            assertionError.initCause(targetException);
+            throw assertionError;
+        }
+    }
+
+    public Object invoke(T t, Object... objArr) throws InvocationTargetException {
+        Method method = getMethod(t.getClass());
+        if (method == null) {
+            throw new AssertionError("Method " + this.methodName + " not supported for object " + t);
+        }
+        try {
+            return method.invoke(t, objArr);
+        } catch (IllegalAccessException e) {
+            AssertionError assertionError = new AssertionError("Unexpectedly could not call: " + method);
+            assertionError.initCause(e);
+            throw assertionError;
+        }
+    }
+
+    public Object invokeWithoutCheckedException(T t, Object... objArr) {
+        try {
+            return invoke(t, objArr);
+        } catch (InvocationTargetException e) {
+            Throwable targetException = e.getTargetException();
+            if (targetException instanceof RuntimeException) {
+                throw ((RuntimeException) targetException);
+            }
+            AssertionError assertionError = new AssertionError("Unexpected exception");
+            assertionError.initCause(targetException);
+            throw assertionError;
+        }
+    }
+
+    private Method getMethod(Class<?> cls) {
+        Class<?> cls2;
+        String str = this.methodName;
+        if (str == null) {
+            return null;
+        }
+        Method publicMethod = getPublicMethod(cls, str, this.methodParams);
+        if (publicMethod == null || (cls2 = this.returnType) == null || cls2.isAssignableFrom(publicMethod.getReturnType())) {
+            return publicMethod;
+        }
+        return null;
+    }
+
+    private static Method getPublicMethod(Class<?> cls, String str, Class[] clsArr) {
+        try {
+            Method method = cls.getMethod(str, clsArr);
+            try {
+                if ((method.getModifiers() & 1) == 0) {
+                    return null;
+                }
+            } catch (NoSuchMethodException unused) {
+            }
+            return method;
+        } catch (NoSuchMethodException unused2) {
+            return null;
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/thrid/okhttp/internal/platform/Platform.java

@@ -0,0 +1,214 @@
+package com.mbridge.msdk.thrid.okhttp.internal.platform;
+
+import com.mbridge.msdk.thrid.okhttp.OkHttpClient;
+import com.mbridge.msdk.thrid.okhttp.Protocol;
+import com.mbridge.msdk.thrid.okhttp.internal.tls.BasicCertificateChainCleaner;
+import com.mbridge.msdk.thrid.okhttp.internal.tls.BasicTrustRootIndex;
+import com.mbridge.msdk.thrid.okhttp.internal.tls.CertificateChainCleaner;
+import com.mbridge.msdk.thrid.okhttp.internal.tls.TrustRootIndex;
+import com.mbridge.msdk.thrid.okio.Buffer;
+import java.io.IOException;
+import java.lang.reflect.Field;
+import java.net.InetSocketAddress;
+import java.net.Socket;
+import java.security.NoSuchAlgorithmException;
+import java.security.Security;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import javax.net.ssl.SSLContext;
+import javax.net.ssl.SSLSocket;
+import javax.net.ssl.SSLSocketFactory;
+import javax.net.ssl.X509TrustManager;
+
+/* loaded from: classes4.dex */
+public class Platform {
+    public static final int INFO = 4;
+    public static final int WARN = 5;
+    private static final Platform PLATFORM = findPlatform();
+    private static final Logger logger = Logger.getLogger(OkHttpClient.class.getName());
+
+    public static Platform get() {
+        return PLATFORM;
+    }
+
+    public void afterHandshake(SSLSocket sSLSocket) {
+    }
+
+    public void configureSslSocketFactory(SSLSocketFactory sSLSocketFactory) {
+    }
+
+    public void configureTlsExtensions(SSLSocket sSLSocket, String str, List<Protocol> list) throws IOException {
+    }
+
+    public String getPrefix() {
+        return "OkHttp";
+    }
+
+    public String getSelectedProtocol(SSLSocket sSLSocket) {
+        return null;
+    }
+
+    public boolean isCleartextTrafficPermitted(String str) {
+        return true;
+    }
+
+    public X509TrustManager trustManager(SSLSocketFactory sSLSocketFactory) {
+        try {
+            Object readFieldOrNull = readFieldOrNull(sSLSocketFactory, Class.forName("sun.security.ssl.SSLContextImpl"), "context");
+            if (readFieldOrNull == null) {
+                return null;
+            }
+            return (X509TrustManager) readFieldOrNull(readFieldOrNull, X509TrustManager.class, "trustManager");
+        } catch (ClassNotFoundException unused) {
+            return null;
+        }
+    }
+
+    public void connectSocket(Socket socket, InetSocketAddress inetSocketAddress, int i) throws IOException {
+        socket.connect(inetSocketAddress, i);
+    }
+
+    public void log(int i, String str, Throwable th) {
+        logger.log(i == 5 ? Level.WARNING : Level.INFO, str, th);
+    }
+
+    public Object getStackTraceForCloseable(String str) {
+        if (logger.isLoggable(Level.FINE)) {
+            return new Throwable(str);
+        }
+        return null;
+    }
+
+    public void logCloseableLeak(String str, Object obj) {
+        if (obj == null) {
+            str = str + " To see where this was allocated, set the OkHttpClient logger level to FINE: Logger.getLogger(OkHttpClient.class.getName()).setLevel(Level.FINE);";
+        }
+        log(5, str, (Throwable) obj);
+    }
+
+    public static List<String> alpnProtocolNames(List<Protocol> list) {
+        ArrayList arrayList = new ArrayList(list.size());
+        int size = list.size();
+        for (int i = 0; i < size; i++) {
+            Protocol protocol = list.get(i);
+            if (protocol != Protocol.HTTP_1_0) {
+                arrayList.add(protocol.toString());
+            }
+        }
+        return arrayList;
+    }
+
+    public CertificateChainCleaner buildCertificateChainCleaner(X509TrustManager x509TrustManager) {
+        return new BasicCertificateChainCleaner(buildTrustRootIndex(x509TrustManager));
+    }
+
+    public CertificateChainCleaner buildCertificateChainCleaner(SSLSocketFactory sSLSocketFactory) {
+        X509TrustManager trustManager = trustManager(sSLSocketFactory);
+        if (trustManager == null) {
+            throw new IllegalStateException("Unable to extract the trust manager on " + get() + ", sslSocketFactory is " + sSLSocketFactory.getClass());
+        }
+        return buildCertificateChainCleaner(trustManager);
+    }
+
+    public static boolean isConscryptPreferred() {
+        if ("conscrypt".equals(System.getProperty("okhttp.platform"))) {
+            return true;
+        }
+        return "Conscrypt".equals(Security.getProviders()[0].getName());
+    }
+
+    private static Platform findPlatform() {
+        if (isAndroid()) {
+            return findAndroidPlatform();
+        }
+        return findJvmPlatform();
+    }
+
+    public static boolean isAndroid() {
+        return "Dalvik".equals(System.getProperty("java.vm.name"));
+    }
+
+    private static Platform findJvmPlatform() {
+        ConscryptPlatform buildIfSupported;
+        if (isConscryptPreferred() && (buildIfSupported = ConscryptPlatform.buildIfSupported()) != null) {
+            return buildIfSupported;
+        }
+        Jdk9Platform buildIfSupported2 = Jdk9Platform.buildIfSupported();
+        if (buildIfSupported2 != null) {
+            return buildIfSupported2;
+        }
+        Platform buildIfSupported3 = JdkWithJettyBootPlatform.buildIfSupported();
+        return buildIfSupported3 != null ? buildIfSupported3 : new Platform();
+    }
+
+    private static Platform findAndroidPlatform() {
+        Platform buildIfSupported = Android10Platform.buildIfSupported();
+        if (buildIfSupported != null) {
+            return buildIfSupported;
+        }
+        Platform buildIfSupported2 = AndroidPlatform.buildIfSupported();
+        if (buildIfSupported2 != null) {
+            return buildIfSupported2;
+        }
+        throw new NullPointerException("No platform found on Android");
+    }
+
+    public static byte[] concatLengthPrefixed(List<Protocol> list) {
+        Buffer buffer = new Buffer();
+        int size = list.size();
+        for (int i = 0; i < size; i++) {
+            Protocol protocol = list.get(i);
+            if (protocol != Protocol.HTTP_1_0) {
+                buffer.writeByte(protocol.toString().length());
+                buffer.writeUtf8(protocol.toString());
+            }
+        }
+        return buffer.readByteArray();
+    }
+
+    public static <T> T readFieldOrNull(Object obj, Class<T> cls, String str) {
+        Object readFieldOrNull;
+        for (Class<?> cls2 = obj.getClass(); cls2 != Object.class; cls2 = cls2.getSuperclass()) {
+            try {
+                Field declaredField = cls2.getDeclaredField(str);
+                declaredField.setAccessible(true);
+                Object obj2 = declaredField.get(obj);
+                if (obj2 != null && cls.isInstance(obj2)) {
+                    return cls.cast(obj2);
+                }
+                return null;
+            } catch (IllegalAccessException unused) {
+                throw new AssertionError();
+            } catch (NoSuchFieldException unused2) {
+            }
+        }
+        if (str.equals("delegate") || (readFieldOrNull = readFieldOrNull(obj, Object.class, "delegate")) == null) {
+            return null;
+        }
+        return (T) readFieldOrNull(readFieldOrNull, cls, str);
+    }
+
+    public SSLContext getSSLContext() {
+        if ("1.7".equals(System.getProperty("java.specification.version"))) {
+            try {
+                return SSLContext.getInstance("TLSv1.2");
+            } catch (NoSuchAlgorithmException unused) {
+            }
+        }
+        try {
+            return SSLContext.getInstance("TLS");
+        } catch (NoSuchAlgorithmException e) {
+            throw new IllegalStateException("No TLS provider", e);
+        }
+    }
+
+    public TrustRootIndex buildTrustRootIndex(X509TrustManager x509TrustManager) {
+        return new BasicTrustRootIndex(x509TrustManager.getAcceptedIssuers());
+    }
+
+    public String toString() {
+        return getClass().getSimpleName();
+    }
+}

decompiled/sources/com/mbridge/msdk/thrid/okhttp/internal/proxy/NullProxySelector.java

@@ -0,0 +1,24 @@
+package com.mbridge.msdk.thrid.okhttp.internal.proxy;
+
+import java.io.IOException;
+import java.net.Proxy;
+import java.net.ProxySelector;
+import java.net.SocketAddress;
+import java.net.URI;
+import java.util.Collections;
+import java.util.List;
+
+/* loaded from: classes4.dex */
+public class NullProxySelector extends ProxySelector {
+    @Override // java.net.ProxySelector
+    public void connectFailed(URI uri, SocketAddress socketAddress, IOException iOException) {
+    }
+
+    @Override // java.net.ProxySelector
+    public List<Proxy> select(URI uri) {
+        if (uri == null) {
+            throw new IllegalArgumentException("uri must not be null");
+        }
+        return Collections.singletonList(Proxy.NO_PROXY);
+    }
+}

decompiled/sources/com/mbridge/msdk/thrid/okhttp/internal/publicsuffix/PublicSuffixDatabase.java

@@ -0,0 +1,269 @@
+package com.mbridge.msdk.thrid.okhttp.internal.publicsuffix;
+
+import androidx.webkit.ProxyConfig;
+import com.mbridge.msdk.thrid.okhttp.internal.Util;
+import com.mbridge.msdk.thrid.okhttp.internal.platform.Platform;
+import com.mbridge.msdk.thrid.okio.BufferedSource;
+import com.mbridge.msdk.thrid.okio.GzipSource;
+import com.mbridge.msdk.thrid.okio.Okio;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InterruptedIOException;
+import java.net.IDN;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+/* loaded from: classes4.dex */
+public final class PublicSuffixDatabase {
+    private static final byte EXCEPTION_MARKER = 33;
+    public static final String PUBLIC_SUFFIX_RESOURCE = "publicsuffixes.gz";
+    private byte[] publicSuffixExceptionListBytes;
+    private byte[] publicSuffixListBytes;
+    private static final byte[] WILDCARD_LABEL = {42};
+    private static final String[] EMPTY_RULE = new String[0];
+    private static final String[] PREVAILING_RULE = {ProxyConfig.MATCH_ALL_SCHEMES};
+    private static final PublicSuffixDatabase instance = new PublicSuffixDatabase();
+    private final AtomicBoolean listRead = new AtomicBoolean(false);
+    private final CountDownLatch readCompleteLatch = new CountDownLatch(1);
+
+    public static PublicSuffixDatabase get() {
+        return instance;
+    }
+
+    public String getEffectiveTldPlusOne(String str) {
+        int length;
+        int length2;
+        if (str == null) {
+            throw new NullPointerException("domain == null");
+        }
+        String[] split = IDN.toUnicode(str).split("\\.");
+        String[] findMatchingRule = findMatchingRule(split);
+        if (split.length == findMatchingRule.length && findMatchingRule[0].charAt(0) != '!') {
+            return null;
+        }
+        if (findMatchingRule[0].charAt(0) == '!') {
+            length = split.length;
+            length2 = findMatchingRule.length;
+        } else {
+            length = split.length;
+            length2 = findMatchingRule.length + 1;
+        }
+        StringBuilder sb = new StringBuilder();
+        String[] split2 = str.split("\\.");
+        for (int i = length - length2; i < split2.length; i++) {
+            sb.append(split2[i]);
+            sb.append('.');
+        }
+        sb.deleteCharAt(sb.length() - 1);
+        return sb.toString();
+    }
+
+    private String[] findMatchingRule(String[] strArr) {
+        String str;
+        String str2;
+        String str3;
+        int i = 0;
+        if (!this.listRead.get() && this.listRead.compareAndSet(false, true)) {
+            readTheListUninterruptibly();
+        } else {
+            try {
+                this.readCompleteLatch.await();
+            } catch (InterruptedException unused) {
+                Thread.currentThread().interrupt();
+            }
+        }
+        synchronized (this) {
+            if (this.publicSuffixListBytes == null) {
+                throw new IllegalStateException("Unable to load publicsuffixes.gz resource from the classpath.");
+            }
+        }
+        int length = strArr.length;
+        byte[][] bArr = new byte[length][];
+        for (int i2 = 0; i2 < strArr.length; i2++) {
+            bArr[i2] = strArr[i2].getBytes(Util.UTF_8);
+        }
+        int i3 = 0;
+        while (true) {
+            str = null;
+            if (i3 >= length) {
+                str2 = null;
+                break;
+            }
+            str2 = binarySearchBytes(this.publicSuffixListBytes, bArr, i3);
+            if (str2 != null) {
+                break;
+            }
+            i3++;
+        }
+        if (length > 1) {
+            byte[][] bArr2 = (byte[][]) bArr.clone();
+            for (int i4 = 0; i4 < bArr2.length - 1; i4++) {
+                bArr2[i4] = WILDCARD_LABEL;
+                str3 = binarySearchBytes(this.publicSuffixListBytes, bArr2, i4);
+                if (str3 != null) {
+                    break;
+                }
+            }
+        }
+        str3 = null;
+        if (str3 != null) {
+            while (true) {
+                if (i >= length - 1) {
+                    break;
+                }
+                String binarySearchBytes = binarySearchBytes(this.publicSuffixExceptionListBytes, bArr, i);
+                if (binarySearchBytes != null) {
+                    str = binarySearchBytes;
+                    break;
+                }
+                i++;
+            }
+        }
+        if (str != null) {
+            return ("!" + str).split("\\.");
+        }
+        if (str2 == null && str3 == null) {
+            return PREVAILING_RULE;
+        }
+        String[] split = str2 != null ? str2.split("\\.") : EMPTY_RULE;
+        String[] split2 = str3 != null ? str3.split("\\.") : EMPTY_RULE;
+        return split.length > split2.length ? split : split2;
+    }
+
+    private static String binarySearchBytes(byte[] bArr, byte[][] bArr2, int i) {
+        int i2;
+        boolean z;
+        int i3;
+        int i4;
+        int length = bArr.length;
+        int i5 = 0;
+        while (i5 < length) {
+            int i6 = (i5 + length) / 2;
+            while (i6 > -1 && bArr[i6] != 10) {
+                i6--;
+            }
+            int i7 = i6 + 1;
+            int i8 = 1;
+            while (true) {
+                i2 = i7 + i8;
+                if (bArr[i2] == 10) {
+                    break;
+                }
+                i8++;
+            }
+            int i9 = i2 - i7;
+            int i10 = i;
+            boolean z2 = false;
+            int i11 = 0;
+            int i12 = 0;
+            while (true) {
+                if (z2) {
+                    i3 = 46;
+                    z = false;
+                } else {
+                    z = z2;
+                    i3 = bArr2[i10][i11] & 255;
+                }
+                i4 = i3 - (bArr[i7 + i12] & 255);
+                if (i4 == 0) {
+                    i12++;
+                    i11++;
+                    if (i12 == i9) {
+                        break;
+                    }
+                    if (bArr2[i10].length != i11) {
+                        z2 = z;
+                    } else {
+                        if (i10 == bArr2.length - 1) {
+                            break;
+                        }
+                        i10++;
+                        i11 = -1;
+                        z2 = true;
+                    }
+                } else {
+                    break;
+                }
+            }
+            if (i4 >= 0) {
+                if (i4 <= 0) {
+                    int i13 = i9 - i12;
+                    int length2 = bArr2[i10].length - i11;
+                    while (true) {
+                        i10++;
+                        if (i10 >= bArr2.length) {
+                            break;
+                        }
+                        length2 += bArr2[i10].length;
+                    }
+                    if (length2 >= i13) {
+                        if (length2 <= i13) {
+                            return new String(bArr, i7, i9, Util.UTF_8);
+                        }
+                    }
+                }
+                i5 = i2 + 1;
+            }
+            length = i6;
+        }
+        return null;
+    }
+
+    private void readTheListUninterruptibly() {
+        boolean z = false;
+        while (true) {
+            try {
+                try {
+                    readTheList();
+                    break;
+                } catch (InterruptedIOException unused) {
+                    Thread.interrupted();
+                    z = true;
+                } catch (IOException e) {
+                    Platform.get().log(5, "Failed to read public suffix list", e);
+                    if (z) {
+                        Thread.currentThread().interrupt();
+                        return;
+                    }
+                    return;
+                }
+            } catch (Throwable th) {
+                if (z) {
+                    Thread.currentThread().interrupt();
+                }
+                throw th;
+            }
+        }
+        if (z) {
+            Thread.currentThread().interrupt();
+        }
+    }
+
+    private void readTheList() throws IOException {
+        InputStream resourceAsStream = PublicSuffixDatabase.class.getResourceAsStream(PUBLIC_SUFFIX_RESOURCE);
+        if (resourceAsStream == null) {
+            return;
+        }
+        BufferedSource buffer = Okio.buffer(new GzipSource(Okio.source(resourceAsStream)));
+        try {
+            byte[] bArr = new byte[buffer.readInt()];
+            buffer.readFully(bArr);
+            byte[] bArr2 = new byte[buffer.readInt()];
+            buffer.readFully(bArr2);
+            synchronized (this) {
+                this.publicSuffixListBytes = bArr;
+                this.publicSuffixExceptionListBytes = bArr2;
+            }
+            this.readCompleteLatch.countDown();
+        } finally {
+            Util.closeQuietly(buffer);
+        }
+    }
+
+    public void setListBytes(byte[] bArr, byte[] bArr2) {
+        this.publicSuffixListBytes = bArr;
+        this.publicSuffixExceptionListBytes = bArr2;
+        this.listRead.set(true);
+        this.readCompleteLatch.countDown();
+    }
+}

decompiled/sources/com/mbridge/msdk/thrid/okhttp/internal/tls/BasicCertificateChainCleaner.java

@@ -0,0 +1,78 @@
+package com.mbridge.msdk.thrid.okhttp.internal.tls;
+
+import java.security.GeneralSecurityException;
+import java.security.cert.Certificate;
+import java.security.cert.X509Certificate;
+import java.util.ArrayDeque;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import javax.net.ssl.SSLPeerUnverifiedException;
+
+/* loaded from: classes4.dex */
+public final class BasicCertificateChainCleaner extends CertificateChainCleaner {
+    private static final int MAX_SIGNERS = 9;
+    private final TrustRootIndex trustRootIndex;
+
+    public BasicCertificateChainCleaner(TrustRootIndex trustRootIndex) {
+        this.trustRootIndex = trustRootIndex;
+    }
+
+    @Override // com.mbridge.msdk.thrid.okhttp.internal.tls.CertificateChainCleaner
+    public List<Certificate> clean(List<Certificate> list, String str) throws SSLPeerUnverifiedException {
+        ArrayDeque arrayDeque = new ArrayDeque(list);
+        ArrayList arrayList = new ArrayList();
+        arrayList.add(arrayDeque.removeFirst());
+        boolean z = false;
+        for (int i = 0; i < 9; i++) {
+            X509Certificate x509Certificate = (X509Certificate) arrayList.get(arrayList.size() - 1);
+            X509Certificate findByIssuerAndSignature = this.trustRootIndex.findByIssuerAndSignature(x509Certificate);
+            if (findByIssuerAndSignature != null) {
+                if (arrayList.size() > 1 || !x509Certificate.equals(findByIssuerAndSignature)) {
+                    arrayList.add(findByIssuerAndSignature);
+                }
+                if (verifySignature(findByIssuerAndSignature, findByIssuerAndSignature)) {
+                    return arrayList;
+                }
+                z = true;
+            } else {
+                Iterator it = arrayDeque.iterator();
+                while (it.hasNext()) {
+                    X509Certificate x509Certificate2 = (X509Certificate) it.next();
+                    if (verifySignature(x509Certificate, x509Certificate2)) {
+                        it.remove();
+                        arrayList.add(x509Certificate2);
+                    }
+                }
+                if (z) {
+                    return arrayList;
+                }
+                throw new SSLPeerUnverifiedException("Failed to find a trusted cert that signed " + x509Certificate);
+            }
+        }
+        throw new SSLPeerUnverifiedException("Certificate chain too long: " + arrayList);
+    }
+
+    private boolean verifySignature(X509Certificate x509Certificate, X509Certificate x509Certificate2) {
+        if (!x509Certificate.getIssuerDN().equals(x509Certificate2.getSubjectDN())) {
+            return false;
+        }
+        try {
+            x509Certificate.verify(x509Certificate2.getPublicKey());
+            return true;
+        } catch (GeneralSecurityException unused) {
+            return false;
+        }
+    }
+
+    public int hashCode() {
+        return this.trustRootIndex.hashCode();
+    }
+
+    public boolean equals(Object obj) {
+        if (obj == this) {
+            return true;
+        }
+        return (obj instanceof BasicCertificateChainCleaner) && ((BasicCertificateChainCleaner) obj).trustRootIndex.equals(this.trustRootIndex);
+    }
+}

decompiled/sources/com/mbridge/msdk/thrid/okhttp/internal/tls/BasicTrustRootIndex.java

@@ -0,0 +1,52 @@
+package com.mbridge.msdk.thrid.okhttp.internal.tls;
+
+import java.security.cert.X509Certificate;
+import java.util.LinkedHashMap;
+import java.util.LinkedHashSet;
+import java.util.Map;
+import java.util.Set;
+import javax.security.auth.x500.X500Principal;
+
+/* loaded from: classes4.dex */
+public final class BasicTrustRootIndex implements TrustRootIndex {
+    private final Map<X500Principal, Set<X509Certificate>> subjectToCaCerts = new LinkedHashMap();
+
+    public BasicTrustRootIndex(X509Certificate... x509CertificateArr) {
+        for (X509Certificate x509Certificate : x509CertificateArr) {
+            X500Principal subjectX500Principal = x509Certificate.getSubjectX500Principal();
+            Set<X509Certificate> set = this.subjectToCaCerts.get(subjectX500Principal);
+            if (set == null) {
+                set = new LinkedHashSet<>(1);
+                this.subjectToCaCerts.put(subjectX500Principal, set);
+            }
+            set.add(x509Certificate);
+        }
+    }
+
+    @Override // com.mbridge.msdk.thrid.okhttp.internal.tls.TrustRootIndex
+    public X509Certificate findByIssuerAndSignature(X509Certificate x509Certificate) {
+        Set<X509Certificate> set = this.subjectToCaCerts.get(x509Certificate.getIssuerX500Principal());
+        if (set == null) {
+            return null;
+        }
+        for (X509Certificate x509Certificate2 : set) {
+            try {
+                x509Certificate.verify(x509Certificate2.getPublicKey());
+                return x509Certificate2;
+            } catch (Exception unused) {
+            }
+        }
+        return null;
+    }
+
+    public boolean equals(Object obj) {
+        if (obj == this) {
+            return true;
+        }
+        return (obj instanceof BasicTrustRootIndex) && ((BasicTrustRootIndex) obj).subjectToCaCerts.equals(this.subjectToCaCerts);
+    }
+
+    public int hashCode() {
+        return this.subjectToCaCerts.hashCode();
+    }
+}

decompiled/sources/com/mbridge/msdk/thrid/okhttp/internal/tls/CertificateChainCleaner.java

@@ -0,0 +1,21 @@
+package com.mbridge.msdk.thrid.okhttp.internal.tls;
+
+import com.mbridge.msdk.thrid.okhttp.internal.platform.Platform;
+import java.security.cert.Certificate;
+import java.security.cert.X509Certificate;
+import java.util.List;
+import javax.net.ssl.SSLPeerUnverifiedException;
+import javax.net.ssl.X509TrustManager;
+
+/* loaded from: classes4.dex */
+public abstract class CertificateChainCleaner {
+    public abstract List<Certificate> clean(List<Certificate> list, String str) throws SSLPeerUnverifiedException;
+
+    public static CertificateChainCleaner get(X509TrustManager x509TrustManager) {
+        return Platform.get().buildCertificateChainCleaner(x509TrustManager);
+    }
+
+    public static CertificateChainCleaner get(X509Certificate... x509CertificateArr) {
+        return new BasicCertificateChainCleaner(new BasicTrustRootIndex(x509CertificateArr));
+    }
+}