971 lines
33 KiB
Java
971 lines
33 KiB
Java
package okhttp3.internal;
|
|
|
|
import com.google.common.net.HttpHeaders;
|
|
import java.io.Closeable;
|
|
import java.io.File;
|
|
import java.io.IOException;
|
|
import java.io.InterruptedIOException;
|
|
import java.net.InetSocketAddress;
|
|
import java.net.ServerSocket;
|
|
import java.net.Socket;
|
|
import java.net.SocketAddress;
|
|
import java.net.SocketTimeoutException;
|
|
import java.nio.charset.Charset;
|
|
import java.nio.charset.StandardCharsets;
|
|
import java.util.ArrayList;
|
|
import java.util.Arrays;
|
|
import java.util.Collection;
|
|
import java.util.Collections;
|
|
import java.util.Comparator;
|
|
import java.util.Iterator;
|
|
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 o.AbstractC14853gaL;
|
|
import o.C14851gaI;
|
|
import o.C14854gaM;
|
|
import o.C14866gag;
|
|
import o.C14881gav;
|
|
import o.C14887gbC;
|
|
import o.C14947gcl;
|
|
import o.C14957gcv;
|
|
import o.C14973gde;
|
|
import o.C15111ghZ;
|
|
import o.C15155gij;
|
|
import o.C15163gir;
|
|
import o.InterfaceC14890gbN;
|
|
import o.InterfaceC14894gbR;
|
|
import o.InterfaceC15148gic;
|
|
import o.InterfaceC15149gid;
|
|
import o.InterfaceC15168giw;
|
|
import o.gbF;
|
|
import o.gcH;
|
|
import o.gcQ;
|
|
import o.gdP;
|
|
import o.gdW;
|
|
import o.gdZ;
|
|
import o.giD;
|
|
import okhttp3.Call;
|
|
import okhttp3.EventListener;
|
|
import okhttp3.Headers;
|
|
import okhttp3.HttpUrl;
|
|
import okhttp3.MediaType;
|
|
import okhttp3.OkHttpClient;
|
|
import okhttp3.RequestBody;
|
|
import okhttp3.Response;
|
|
import okhttp3.ResponseBody;
|
|
import okhttp3.internal.http2.Header;
|
|
import okhttp3.internal.io.FileSystem;
|
|
|
|
/* loaded from: classes.dex */
|
|
public final class Util {
|
|
public static final byte[] EMPTY_BYTE_ARRAY;
|
|
public static final Headers EMPTY_HEADERS = Headers.Companion.of(new String[0]);
|
|
public static final RequestBody EMPTY_REQUEST;
|
|
public static final ResponseBody EMPTY_RESPONSE;
|
|
private static final C15163gir UNICODE_BOMS;
|
|
public static final TimeZone UTC;
|
|
private static final gdW VERIFY_AS_IP_ADDRESS;
|
|
public static final boolean assertionsEnabled;
|
|
public static final String okHttpName;
|
|
public static final String userAgent = "okhttp/4.11.0";
|
|
|
|
public static final int and(byte b, int i) {
|
|
return b & i;
|
|
}
|
|
|
|
public static final int and(short s, int i) {
|
|
return s & i;
|
|
}
|
|
|
|
public static final long and(int i, long j) {
|
|
return i & j;
|
|
}
|
|
|
|
public static final int parseHexDigit(char c) {
|
|
if ('0' <= c && c < ':') {
|
|
return c - '0';
|
|
}
|
|
if ('a' <= c && c < 'g') {
|
|
return c - 'W';
|
|
}
|
|
if ('A' > c || c >= 'G') {
|
|
return -1;
|
|
}
|
|
return c - '7';
|
|
}
|
|
|
|
static {
|
|
byte[] bArr = new byte[0];
|
|
EMPTY_BYTE_ARRAY = bArr;
|
|
EMPTY_RESPONSE = ResponseBody.Companion.create$default(ResponseBody.Companion, bArr, (MediaType) null, 1, (Object) null);
|
|
EMPTY_REQUEST = RequestBody.Companion.create$default(RequestBody.Companion, bArr, (MediaType) null, 0, 0, 7, (Object) null);
|
|
C15163gir.LWm lWm = C15163gir.c;
|
|
C15155gij.LWm lWm2 = C15155gij.c;
|
|
C15155gij b = C15155gij.LWm.b("efbbbf");
|
|
C15155gij.LWm lWm3 = C15155gij.c;
|
|
C15155gij b2 = C15155gij.LWm.b("feff");
|
|
C15155gij.LWm lWm4 = C15155gij.c;
|
|
C15155gij b3 = C15155gij.LWm.b("fffe");
|
|
C15155gij.LWm lWm5 = C15155gij.c;
|
|
C15155gij b4 = C15155gij.LWm.b("0000ffff");
|
|
C15155gij.LWm lWm6 = C15155gij.c;
|
|
UNICODE_BOMS = lWm.a(b, b2, b3, b4, C15155gij.LWm.b("ffff0000"));
|
|
TimeZone timeZone = TimeZone.getTimeZone("GMT");
|
|
C14957gcv.e(timeZone);
|
|
UTC = timeZone;
|
|
VERIFY_AS_IP_ADDRESS = new gdW("([0-9a-fA-F]*:[0-9a-fA-F:.]*)|([\\d.]+)");
|
|
assertionsEnabled = false;
|
|
String name = OkHttpClient.class.getName();
|
|
C14957gcv.c((Object) name, "");
|
|
okHttpName = gdZ.c(gdZ.b(name, "okhttp3."), (CharSequence) "Client");
|
|
}
|
|
|
|
public static final void checkOffsetAndCount(long j, long j2, long j3) {
|
|
if ((j2 | j3) < 0 || j2 > j || j - j2 < j3) {
|
|
throw new ArrayIndexOutOfBoundsException();
|
|
}
|
|
}
|
|
|
|
public static final ThreadFactory threadFactory(final String str, final boolean z) {
|
|
C14957gcv.e(str, "");
|
|
return new ThreadFactory(str, z) { // from class: okhttp3.internal.Util$$ExternalSyntheticLambda0
|
|
public final String f$0;
|
|
public final boolean f$1;
|
|
|
|
@Override // java.util.concurrent.ThreadFactory
|
|
public final Thread newThread(Runnable runnable) {
|
|
Thread m493threadFactory$lambda1;
|
|
m493threadFactory$lambda1 = Util.m493threadFactory$lambda1(this.f$0, this.f$1, runnable);
|
|
return m493threadFactory$lambda1;
|
|
}
|
|
|
|
{
|
|
this.f$0 = str;
|
|
this.f$1 = z;
|
|
}
|
|
};
|
|
}
|
|
|
|
/* JADX INFO: Access modifiers changed from: private */
|
|
/* renamed from: threadFactory$lambda-1, reason: not valid java name */
|
|
public static final Thread m493threadFactory$lambda1(String str, boolean z, Runnable runnable) {
|
|
C14957gcv.e(str, "");
|
|
Thread thread = new Thread(runnable, str);
|
|
thread.setDaemon(z);
|
|
return thread;
|
|
}
|
|
|
|
public static final String[] intersect(String[] strArr, String[] strArr2, Comparator<? super String> comparator) {
|
|
C14957gcv.e(strArr, "");
|
|
C14957gcv.e(strArr2, "");
|
|
C14957gcv.e(comparator, "");
|
|
ArrayList arrayList = new ArrayList();
|
|
int length = strArr.length;
|
|
int i = 0;
|
|
while (i < length) {
|
|
String str = strArr[i];
|
|
i++;
|
|
int length2 = strArr2.length;
|
|
int i2 = 0;
|
|
while (true) {
|
|
if (i2 < length2) {
|
|
String str2 = strArr2[i2];
|
|
i2++;
|
|
if (comparator.compare(str, str2) == 0) {
|
|
arrayList.add(str);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
Object[] array = arrayList.toArray(new String[0]);
|
|
if (array != null) {
|
|
return (String[]) array;
|
|
}
|
|
throw new NullPointerException("null cannot be cast to non-null type kotlin.Array<T of kotlin.collections.ArraysKt__ArraysJVMKt.toTypedArray>");
|
|
}
|
|
|
|
/* JADX WARN: Multi-variable type inference failed */
|
|
public static final boolean hasIntersection(String[] strArr, String[] strArr2, Comparator<? super String> comparator) {
|
|
C14957gcv.e(strArr, "");
|
|
C14957gcv.e(comparator, "");
|
|
if (strArr.length != 0 && strArr2 != null && strArr2.length != 0) {
|
|
int length = strArr.length;
|
|
int i = 0;
|
|
while (i < length) {
|
|
String str = strArr[i];
|
|
i++;
|
|
C14957gcv.e(strArr2, "");
|
|
C14947gcl c14947gcl = new C14947gcl(strArr2);
|
|
while (c14947gcl.hasNext()) {
|
|
if (comparator.compare(str, (String) c14947gcl.next()) == 0) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public static /* synthetic */ String toHostHeader$default(HttpUrl httpUrl, boolean z, int i, Object obj) {
|
|
if ((i & 1) != 0) {
|
|
z = false;
|
|
}
|
|
return toHostHeader(httpUrl, z);
|
|
}
|
|
|
|
public static final String toHostHeader(HttpUrl httpUrl, boolean z) {
|
|
String host;
|
|
C14957gcv.e(httpUrl, "");
|
|
if (gdZ.d((CharSequence) httpUrl.host(), (CharSequence) ":", false)) {
|
|
StringBuilder sb = new StringBuilder("[");
|
|
sb.append(httpUrl.host());
|
|
sb.append(']');
|
|
host = sb.toString();
|
|
} else {
|
|
host = httpUrl.host();
|
|
}
|
|
if (!z && httpUrl.port() == HttpUrl.Companion.defaultPort(httpUrl.scheme())) {
|
|
return host;
|
|
}
|
|
StringBuilder sb2 = new StringBuilder();
|
|
sb2.append(host);
|
|
sb2.append(':');
|
|
sb2.append(httpUrl.port());
|
|
return sb2.toString();
|
|
}
|
|
|
|
public static final String[] concat(String[] strArr, String str) {
|
|
C14957gcv.e(strArr, "");
|
|
C14957gcv.e(str, "");
|
|
Object[] copyOf = Arrays.copyOf(strArr, strArr.length + 1);
|
|
C14957gcv.c(copyOf, "");
|
|
String[] strArr2 = (String[]) copyOf;
|
|
C14957gcv.e(strArr2, "");
|
|
strArr2[strArr2.length - 1] = str;
|
|
return strArr2;
|
|
}
|
|
|
|
public static /* synthetic */ int indexOfFirstNonAsciiWhitespace$default(String str, int i, int i2, int i3, Object obj) {
|
|
if ((i3 & 1) != 0) {
|
|
i = 0;
|
|
}
|
|
if ((i3 & 2) != 0) {
|
|
i2 = str.length();
|
|
}
|
|
return indexOfFirstNonAsciiWhitespace(str, i, i2);
|
|
}
|
|
|
|
public static final int indexOfFirstNonAsciiWhitespace(String str, int i, int i2) {
|
|
C14957gcv.e(str, "");
|
|
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 /* synthetic */ int indexOfLastNonAsciiWhitespace$default(String str, int i, int i2, int i3, Object obj) {
|
|
if ((i3 & 1) != 0) {
|
|
i = 0;
|
|
}
|
|
if ((i3 & 2) != 0) {
|
|
i2 = str.length();
|
|
}
|
|
return indexOfLastNonAsciiWhitespace(str, i, i2);
|
|
}
|
|
|
|
public static final int indexOfLastNonAsciiWhitespace(String str, int i, int i2) {
|
|
C14957gcv.e(str, "");
|
|
int i3 = i2 - 1;
|
|
if (i <= i3) {
|
|
while (true) {
|
|
char charAt = str.charAt(i3);
|
|
if (charAt != '\t' && charAt != '\n' && charAt != '\f' && charAt != '\r' && charAt != ' ') {
|
|
return i3 + 1;
|
|
}
|
|
if (i3 == i) {
|
|
break;
|
|
}
|
|
i3--;
|
|
}
|
|
}
|
|
return i;
|
|
}
|
|
|
|
public static /* synthetic */ String trimSubstring$default(String str, int i, int i2, int i3, Object obj) {
|
|
if ((i3 & 1) != 0) {
|
|
i = 0;
|
|
}
|
|
if ((i3 & 2) != 0) {
|
|
i2 = str.length();
|
|
}
|
|
return trimSubstring(str, i, i2);
|
|
}
|
|
|
|
public static final String trimSubstring(String str, int i, int i2) {
|
|
C14957gcv.e(str, "");
|
|
int indexOfFirstNonAsciiWhitespace = indexOfFirstNonAsciiWhitespace(str, i, i2);
|
|
String substring = str.substring(indexOfFirstNonAsciiWhitespace, indexOfLastNonAsciiWhitespace(str, indexOfFirstNonAsciiWhitespace, i2));
|
|
C14957gcv.c((Object) substring, "");
|
|
return substring;
|
|
}
|
|
|
|
public static /* synthetic */ int delimiterOffset$default(String str, String str2, int i, int i2, int i3, Object obj) {
|
|
if ((i3 & 2) != 0) {
|
|
i = 0;
|
|
}
|
|
if ((i3 & 4) != 0) {
|
|
i2 = str.length();
|
|
}
|
|
return delimiterOffset(str, str2, i, i2);
|
|
}
|
|
|
|
public static final int delimiterOffset(String str, String str2, int i, int i2) {
|
|
C14957gcv.e(str, "");
|
|
C14957gcv.e(str2, "");
|
|
while (i < i2) {
|
|
String str3 = str2;
|
|
char charAt = str.charAt(i);
|
|
C14957gcv.e(str3, "");
|
|
if (gdZ.a((CharSequence) str3, charAt, 0, false) >= 0) {
|
|
return i;
|
|
}
|
|
i++;
|
|
}
|
|
return i2;
|
|
}
|
|
|
|
public static /* synthetic */ int delimiterOffset$default(String str, char c, int i, int i2, int i3, Object obj) {
|
|
if ((i3 & 2) != 0) {
|
|
i = 0;
|
|
}
|
|
if ((i3 & 4) != 0) {
|
|
i2 = str.length();
|
|
}
|
|
return delimiterOffset(str, c, i, i2);
|
|
}
|
|
|
|
public static final int delimiterOffset(String str, char c, int i, int i2) {
|
|
C14957gcv.e(str, "");
|
|
while (i < i2) {
|
|
if (str.charAt(i) == c) {
|
|
return i;
|
|
}
|
|
i++;
|
|
}
|
|
return i2;
|
|
}
|
|
|
|
public static final int indexOfControlOrNonAscii(String str) {
|
|
C14957gcv.e(str, "");
|
|
int length = str.length();
|
|
for (int i = 0; i < length; i++) {
|
|
char charAt = str.charAt(i);
|
|
if (C14957gcv.a(charAt, 31) <= 0 || C14957gcv.a(charAt, 127) >= 0) {
|
|
return i;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
public static final boolean canParseAsIpAddress(String str) {
|
|
C14957gcv.e(str, "");
|
|
gdW gdw = VERIFY_AS_IP_ADDRESS;
|
|
String str2 = str;
|
|
C14957gcv.e(str2, "");
|
|
return gdw.e.matcher(str2).matches();
|
|
}
|
|
|
|
public static final boolean isSensitiveHeader(String str) {
|
|
C14957gcv.e(str, "");
|
|
return gdZ.a(str, HttpHeaders.AUTHORIZATION, true) || gdZ.a(str, HttpHeaders.COOKIE, true) || gdZ.a(str, HttpHeaders.PROXY_AUTHORIZATION, true) || gdZ.a(str, HttpHeaders.SET_COOKIE, true);
|
|
}
|
|
|
|
public static final String format(String str, Object... objArr) {
|
|
C14957gcv.e(str, "");
|
|
C14957gcv.e(objArr, "");
|
|
gcH gch = gcH.d;
|
|
Locale locale = Locale.US;
|
|
Object[] copyOf = Arrays.copyOf(objArr, objArr.length);
|
|
String format = String.format(locale, str, Arrays.copyOf(copyOf, copyOf.length));
|
|
C14957gcv.c((Object) format, "");
|
|
return format;
|
|
}
|
|
|
|
public static final Charset readBomAsCharset(InterfaceC15149gid interfaceC15149gid, Charset charset) throws IOException {
|
|
Charset forName;
|
|
C14957gcv.e(interfaceC15149gid, "");
|
|
C14957gcv.e(charset, "");
|
|
int c = interfaceC15149gid.c(UNICODE_BOMS);
|
|
if (c == -1) {
|
|
return charset;
|
|
}
|
|
if (c == 0) {
|
|
Charset charset2 = StandardCharsets.UTF_8;
|
|
C14957gcv.c(charset2, "");
|
|
return charset2;
|
|
}
|
|
if (c == 1) {
|
|
Charset charset3 = StandardCharsets.UTF_16BE;
|
|
C14957gcv.c(charset3, "");
|
|
return charset3;
|
|
}
|
|
if (c == 2) {
|
|
Charset charset4 = StandardCharsets.UTF_16LE;
|
|
C14957gcv.c(charset4, "");
|
|
return charset4;
|
|
}
|
|
if (c == 3) {
|
|
gdP gdp = gdP.b;
|
|
Charset charset5 = gdP.d;
|
|
if (charset5 != null) {
|
|
return charset5;
|
|
}
|
|
forName = Charset.forName("UTF-32BE");
|
|
C14957gcv.c(forName, "");
|
|
gdP.d = forName;
|
|
} else if (c == 4) {
|
|
gdP gdp2 = gdP.b;
|
|
Charset charset6 = gdP.c;
|
|
if (charset6 != null) {
|
|
return charset6;
|
|
}
|
|
forName = Charset.forName("UTF-32LE");
|
|
C14957gcv.c(forName, "");
|
|
gdP.c = forName;
|
|
} else {
|
|
throw new AssertionError();
|
|
}
|
|
return forName;
|
|
}
|
|
|
|
public static final int checkDuration(String str, long j, TimeUnit timeUnit) {
|
|
C14957gcv.e(str, "");
|
|
if (j < 0) {
|
|
throw new IllegalStateException(C14957gcv.c(str, (Object) " < 0").toString());
|
|
}
|
|
if (timeUnit == null) {
|
|
throw new IllegalStateException("unit == null".toString());
|
|
}
|
|
long millis = timeUnit.toMillis(j);
|
|
if (millis > 2147483647L) {
|
|
throw new IllegalArgumentException(C14957gcv.c(str, (Object) " too large.").toString());
|
|
}
|
|
if (millis != 0 || j <= 0) {
|
|
return (int) millis;
|
|
}
|
|
throw new IllegalArgumentException(C14957gcv.c(str, (Object) " too small.").toString());
|
|
}
|
|
|
|
public static final Headers toHeaders(List<Header> list) {
|
|
C14957gcv.e(list, "");
|
|
Headers.Builder builder = new Headers.Builder();
|
|
for (Header header : list) {
|
|
C15155gij component1 = header.component1();
|
|
C15155gij component2 = header.component2();
|
|
String str = component1.d;
|
|
if (str == null) {
|
|
byte[] b = component1.b();
|
|
C14957gcv.e(b, "");
|
|
String str2 = new String(b, gdP.a);
|
|
component1.d = str2;
|
|
str = str2;
|
|
}
|
|
String str3 = component2.d;
|
|
if (str3 == null) {
|
|
byte[] b2 = component2.b();
|
|
C14957gcv.e(b2, "");
|
|
String str4 = new String(b2, gdP.a);
|
|
component2.d = str4;
|
|
str3 = str4;
|
|
}
|
|
builder.addLenient$okhttp(str, str3);
|
|
}
|
|
return builder.build();
|
|
}
|
|
|
|
public static final List<Header> toHeaderList(Headers headers) {
|
|
Iterable c14973gde;
|
|
C14957gcv.e(headers, "");
|
|
int size = headers.size();
|
|
if (size <= Integer.MIN_VALUE) {
|
|
C14973gde.LWm lWm = C14973gde.c;
|
|
c14973gde = C14973gde.f;
|
|
} else {
|
|
c14973gde = new C14973gde(0, size - 1);
|
|
}
|
|
Iterable iterable = c14973gde;
|
|
C14957gcv.e(iterable, "");
|
|
ArrayList arrayList = new ArrayList(iterable instanceof Collection ? ((Collection) iterable).size() : 10);
|
|
Iterator it = iterable.iterator();
|
|
while (it.hasNext()) {
|
|
int a = ((AbstractC14853gaL) it).a();
|
|
arrayList.add(new Header(headers.name(a), headers.value(a)));
|
|
}
|
|
return arrayList;
|
|
}
|
|
|
|
public static final boolean canReuseConnectionFor(HttpUrl httpUrl, HttpUrl httpUrl2) {
|
|
C14957gcv.e(httpUrl, "");
|
|
C14957gcv.e(httpUrl2, "");
|
|
return C14957gcv.b((Object) httpUrl.host(), (Object) httpUrl2.host()) && httpUrl.port() == httpUrl2.port() && C14957gcv.b((Object) httpUrl.scheme(), (Object) httpUrl2.scheme());
|
|
}
|
|
|
|
public static final EventListener.Factory asFactory(final EventListener eventListener) {
|
|
C14957gcv.e(eventListener, "");
|
|
return new EventListener.Factory(eventListener) { // from class: okhttp3.internal.Util$$ExternalSyntheticLambda1
|
|
public final EventListener f$0;
|
|
|
|
@Override // okhttp3.EventListener.Factory
|
|
public final EventListener create(Call call) {
|
|
EventListener m492asFactory$lambda8;
|
|
m492asFactory$lambda8 = Util.m492asFactory$lambda8(this.f$0, call);
|
|
return m492asFactory$lambda8;
|
|
}
|
|
|
|
{
|
|
this.f$0 = eventListener;
|
|
}
|
|
};
|
|
}
|
|
|
|
public static final void writeMedium(InterfaceC15148gic interfaceC15148gic, int i) throws IOException {
|
|
C14957gcv.e(interfaceC15148gic, "");
|
|
interfaceC15148gic.b((i >>> 16) & 255);
|
|
interfaceC15148gic.b((i >>> 8) & 255);
|
|
interfaceC15148gic.b(i & 255);
|
|
}
|
|
|
|
public static final int readMedium(InterfaceC15149gid interfaceC15149gid) throws IOException {
|
|
C14957gcv.e(interfaceC15149gid, "");
|
|
return and(interfaceC15149gid.f(), 255) | (and(interfaceC15149gid.f(), 255) << 16) | (and(interfaceC15149gid.f(), 255) << 8);
|
|
}
|
|
|
|
public static final boolean skipAll(giD gid, int i, TimeUnit timeUnit) throws IOException {
|
|
C14957gcv.e(gid, "");
|
|
C14957gcv.e(timeUnit, "");
|
|
long nanoTime = System.nanoTime();
|
|
long deadlineNanoTime = gid.timeout().hasDeadline() ? gid.timeout().deadlineNanoTime() - nanoTime : Long.MAX_VALUE;
|
|
gid.timeout().deadlineNanoTime(Math.min(deadlineNanoTime, timeUnit.toNanos(i)) + nanoTime);
|
|
try {
|
|
C15111ghZ c15111ghZ = new C15111ghZ();
|
|
while (gid.read(c15111ghZ, 8192L) != -1) {
|
|
c15111ghZ.j(c15111ghZ.c);
|
|
}
|
|
if (deadlineNanoTime == Long.MAX_VALUE) {
|
|
gid.timeout().clearDeadline();
|
|
} else {
|
|
gid.timeout().deadlineNanoTime(nanoTime + deadlineNanoTime);
|
|
}
|
|
return true;
|
|
} catch (InterruptedIOException unused) {
|
|
if (deadlineNanoTime == Long.MAX_VALUE) {
|
|
gid.timeout().clearDeadline();
|
|
} else {
|
|
gid.timeout().deadlineNanoTime(nanoTime + deadlineNanoTime);
|
|
}
|
|
return false;
|
|
} catch (Throwable th) {
|
|
if (deadlineNanoTime == Long.MAX_VALUE) {
|
|
gid.timeout().clearDeadline();
|
|
} else {
|
|
gid.timeout().deadlineNanoTime(nanoTime + deadlineNanoTime);
|
|
}
|
|
throw th;
|
|
}
|
|
}
|
|
|
|
public static final boolean discard(giD gid, int i, TimeUnit timeUnit) {
|
|
C14957gcv.e(gid, "");
|
|
C14957gcv.e(timeUnit, "");
|
|
try {
|
|
return skipAll(gid, i, timeUnit);
|
|
} catch (IOException unused) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public static final String peerName(Socket socket) {
|
|
C14957gcv.e(socket, "");
|
|
SocketAddress remoteSocketAddress = socket.getRemoteSocketAddress();
|
|
if (!(remoteSocketAddress instanceof InetSocketAddress)) {
|
|
return remoteSocketAddress.toString();
|
|
}
|
|
String hostName = ((InetSocketAddress) remoteSocketAddress).getHostName();
|
|
C14957gcv.c((Object) hostName, "");
|
|
return hostName;
|
|
}
|
|
|
|
public static final boolean isHealthy(Socket socket, InterfaceC15149gid interfaceC15149gid) {
|
|
C14957gcv.e(socket, "");
|
|
C14957gcv.e(interfaceC15149gid, "");
|
|
try {
|
|
int soTimeout = socket.getSoTimeout();
|
|
try {
|
|
socket.setSoTimeout(1);
|
|
boolean j = interfaceC15149gid.j();
|
|
socket.setSoTimeout(soTimeout);
|
|
return true ^ j;
|
|
} catch (Throwable th) {
|
|
socket.setSoTimeout(soTimeout);
|
|
throw th;
|
|
}
|
|
} catch (SocketTimeoutException unused) {
|
|
return true;
|
|
} catch (IOException unused2) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public static final void ignoreIoExceptions(InterfaceC14890gbN<C14866gag> interfaceC14890gbN) {
|
|
C14957gcv.e(interfaceC14890gbN, "");
|
|
try {
|
|
interfaceC14890gbN.invoke();
|
|
} catch (IOException unused) {
|
|
}
|
|
}
|
|
|
|
public static final void threadName(String str, InterfaceC14890gbN<C14866gag> interfaceC14890gbN) {
|
|
C14957gcv.e(str, "");
|
|
C14957gcv.e(interfaceC14890gbN, "");
|
|
Thread currentThread = Thread.currentThread();
|
|
String name = currentThread.getName();
|
|
currentThread.setName(str);
|
|
try {
|
|
interfaceC14890gbN.invoke();
|
|
} finally {
|
|
currentThread.setName(name);
|
|
}
|
|
}
|
|
|
|
public static /* synthetic */ int indexOfNonWhitespace$default(String str, int i, int i2, Object obj) {
|
|
if ((i2 & 1) != 0) {
|
|
i = 0;
|
|
}
|
|
return indexOfNonWhitespace(str, i);
|
|
}
|
|
|
|
public static final int indexOfNonWhitespace(String str, int i) {
|
|
C14957gcv.e(str, "");
|
|
int length = str.length();
|
|
while (i < length) {
|
|
char charAt = str.charAt(i);
|
|
if (charAt != ' ' && charAt != '\t') {
|
|
return i;
|
|
}
|
|
i++;
|
|
}
|
|
return str.length();
|
|
}
|
|
|
|
public static final long headersContentLength(Response response) {
|
|
C14957gcv.e(response, "");
|
|
String str = response.headers().get(HttpHeaders.CONTENT_LENGTH);
|
|
if (str != null) {
|
|
return toLongOrDefault(str, -1L);
|
|
}
|
|
return -1L;
|
|
}
|
|
|
|
public static final long toLongOrDefault(String str, long j) {
|
|
C14957gcv.e(str, "");
|
|
try {
|
|
return Long.parseLong(str);
|
|
} catch (NumberFormatException unused) {
|
|
return j;
|
|
}
|
|
}
|
|
|
|
public static final int toNonNegativeInt(String str, int i) {
|
|
Long valueOf;
|
|
if (str == null) {
|
|
valueOf = null;
|
|
} else {
|
|
try {
|
|
valueOf = Long.valueOf(Long.parseLong(str));
|
|
} catch (NumberFormatException unused) {
|
|
return i;
|
|
}
|
|
}
|
|
if (valueOf == null) {
|
|
return i;
|
|
}
|
|
long longValue = valueOf.longValue();
|
|
if (longValue > 2147483647L) {
|
|
return Integer.MAX_VALUE;
|
|
}
|
|
if (longValue < 0) {
|
|
return 0;
|
|
}
|
|
return (int) longValue;
|
|
}
|
|
|
|
public static final <T> List<T> toImmutableList(List<? extends T> list) {
|
|
C14957gcv.e(list, "");
|
|
List<? extends T> list2 = list;
|
|
C14957gcv.e(list2, "");
|
|
List<T> unmodifiableList = Collections.unmodifiableList(new ArrayList(list2));
|
|
C14957gcv.c(unmodifiableList, "");
|
|
return unmodifiableList;
|
|
}
|
|
|
|
@SafeVarargs
|
|
public static final <T> List<T> immutableListOf(T... tArr) {
|
|
C14957gcv.e(tArr, "");
|
|
Object[] objArr = (Object[]) tArr.clone();
|
|
List<T> unmodifiableList = Collections.unmodifiableList(C14881gav.e(Arrays.copyOf(objArr, objArr.length)));
|
|
C14957gcv.c(unmodifiableList, "");
|
|
return unmodifiableList;
|
|
}
|
|
|
|
public static final <K, V> Map<K, V> toImmutableMap(Map<K, ? extends V> map) {
|
|
C14957gcv.e(map, "");
|
|
if (!map.isEmpty()) {
|
|
Map<K, V> unmodifiableMap = Collections.unmodifiableMap(new LinkedHashMap(map));
|
|
C14957gcv.c(unmodifiableMap, "");
|
|
return unmodifiableMap;
|
|
}
|
|
C14854gaM c14854gaM = C14854gaM.c;
|
|
C14957gcv.d(c14854gaM, "");
|
|
return c14854gaM;
|
|
}
|
|
|
|
public static final void closeQuietly(Closeable closeable) {
|
|
C14957gcv.e(closeable, "");
|
|
try {
|
|
closeable.close();
|
|
} catch (RuntimeException e) {
|
|
throw e;
|
|
} catch (Exception unused) {
|
|
}
|
|
}
|
|
|
|
public static final void closeQuietly(Socket socket) {
|
|
C14957gcv.e(socket, "");
|
|
try {
|
|
socket.close();
|
|
} catch (AssertionError e) {
|
|
throw e;
|
|
} catch (RuntimeException e2) {
|
|
if (!C14957gcv.b((Object) e2.getMessage(), (Object) "bio == null")) {
|
|
throw e2;
|
|
}
|
|
} catch (Exception unused) {
|
|
}
|
|
}
|
|
|
|
public static final void closeQuietly(ServerSocket serverSocket) {
|
|
C14957gcv.e(serverSocket, "");
|
|
try {
|
|
serverSocket.close();
|
|
} catch (RuntimeException e) {
|
|
throw e;
|
|
} catch (Exception unused) {
|
|
}
|
|
}
|
|
|
|
public static final boolean isCivilized(FileSystem fileSystem, File file) {
|
|
C14957gcv.e(fileSystem, "");
|
|
C14957gcv.e(file, "");
|
|
InterfaceC15168giw sink = fileSystem.sink(file);
|
|
try {
|
|
InterfaceC15168giw interfaceC15168giw = sink;
|
|
try {
|
|
fileSystem.delete(file);
|
|
gbF.d(sink, null);
|
|
return true;
|
|
} catch (IOException unused) {
|
|
C14866gag c14866gag = C14866gag.c;
|
|
gbF.d(sink, null);
|
|
fileSystem.delete(file);
|
|
return false;
|
|
}
|
|
} finally {
|
|
}
|
|
}
|
|
|
|
public static final String toHexString(long j) {
|
|
String hexString = Long.toHexString(j);
|
|
C14957gcv.c((Object) hexString, "");
|
|
return hexString;
|
|
}
|
|
|
|
public static final String toHexString(int i) {
|
|
String hexString = Integer.toHexString(i);
|
|
C14957gcv.c((Object) hexString, "");
|
|
return hexString;
|
|
}
|
|
|
|
public static final void wait(Object obj) {
|
|
C14957gcv.e(obj, "");
|
|
obj.wait();
|
|
}
|
|
|
|
public static final void notify(Object obj) {
|
|
C14957gcv.e(obj, "");
|
|
obj.notify();
|
|
}
|
|
|
|
public static final void notifyAll(Object obj) {
|
|
C14957gcv.e(obj, "");
|
|
obj.notifyAll();
|
|
}
|
|
|
|
/* JADX WARN: Code restructure failed: missing block: B:17:0x003e, code lost:
|
|
|
|
if (o.C14957gcv.b((java.lang.Object) r7, (java.lang.Object) "delegate") != false) goto L22;
|
|
*/
|
|
/* JADX WARN: Code restructure failed: missing block: B:18:0x0040, code lost:
|
|
|
|
r5 = readFieldOrNull(r5, java.lang.Object.class, "delegate");
|
|
*/
|
|
/*
|
|
Code decompiled incorrectly, please refer to instructions dump.
|
|
To view partially-correct add '--show-bad-code' argument
|
|
*/
|
|
public static final <T> T readFieldOrNull(java.lang.Object r5, java.lang.Class<T> r6, java.lang.String r7) {
|
|
/*
|
|
L0:
|
|
java.lang.String r0 = ""
|
|
o.C14957gcv.e(r5, r0)
|
|
o.C14957gcv.e(r6, r0)
|
|
o.C14957gcv.e(r7, r0)
|
|
java.lang.Class r1 = r5.getClass()
|
|
Lf:
|
|
java.lang.Class<java.lang.Object> r2 = java.lang.Object.class
|
|
boolean r2 = o.C14957gcv.b(r1, r2)
|
|
r3 = 0
|
|
if (r2 != 0) goto L38
|
|
java.lang.reflect.Field r2 = r1.getDeclaredField(r7) // Catch: java.lang.NoSuchFieldException -> L30
|
|
r4 = 1
|
|
r2.setAccessible(r4) // Catch: java.lang.NoSuchFieldException -> L30
|
|
java.lang.Object r2 = r2.get(r5) // Catch: java.lang.NoSuchFieldException -> L30
|
|
boolean r4 = r6.isInstance(r2) // Catch: java.lang.NoSuchFieldException -> L30
|
|
if (r4 != 0) goto L2b
|
|
goto L2f
|
|
L2b:
|
|
java.lang.Object r3 = r6.cast(r2) // Catch: java.lang.NoSuchFieldException -> L30
|
|
L2f:
|
|
return r3
|
|
L30:
|
|
java.lang.Class r1 = r1.getSuperclass()
|
|
o.C14957gcv.c(r1, r0)
|
|
goto Lf
|
|
L38:
|
|
java.lang.String r0 = "delegate"
|
|
boolean r1 = o.C14957gcv.b(r7, r0)
|
|
if (r1 != 0) goto L49
|
|
java.lang.Class<java.lang.Object> r1 = java.lang.Object.class
|
|
java.lang.Object r5 = readFieldOrNull(r5, r1, r0)
|
|
if (r5 == 0) goto L49
|
|
goto L0
|
|
L49:
|
|
return r3
|
|
*/
|
|
throw new UnsupportedOperationException("Method not decompiled: okhttp3.internal.Util.readFieldOrNull(java.lang.Object, java.lang.Class, java.lang.String):java.lang.Object");
|
|
}
|
|
|
|
public static final <E> void addIfAbsent(List<E> list, E e) {
|
|
C14957gcv.e(list, "");
|
|
if (list.contains(e)) {
|
|
return;
|
|
}
|
|
list.add(e);
|
|
}
|
|
|
|
public static final void assertThreadHoldsLock(Object obj) {
|
|
C14957gcv.e(obj, "");
|
|
if (!assertionsEnabled || Thread.holdsLock(obj)) {
|
|
return;
|
|
}
|
|
StringBuilder sb = new StringBuilder("Thread ");
|
|
sb.append((Object) Thread.currentThread().getName());
|
|
sb.append(" MUST hold lock on ");
|
|
sb.append(obj);
|
|
throw new AssertionError(sb.toString());
|
|
}
|
|
|
|
public static final void assertThreadDoesntHoldLock(Object obj) {
|
|
C14957gcv.e(obj, "");
|
|
if (assertionsEnabled && Thread.holdsLock(obj)) {
|
|
StringBuilder sb = new StringBuilder("Thread ");
|
|
sb.append((Object) Thread.currentThread().getName());
|
|
sb.append(" MUST NOT hold lock on ");
|
|
sb.append(obj);
|
|
throw new AssertionError(sb.toString());
|
|
}
|
|
}
|
|
|
|
public static final Throwable withSuppressed(Exception exc, List<? extends Exception> list) {
|
|
C14957gcv.e(exc, "");
|
|
C14957gcv.e(list, "");
|
|
if (list.size() > 1) {
|
|
System.out.println(list);
|
|
}
|
|
for (Exception exc2 : list) {
|
|
Exception exc3 = exc;
|
|
C14957gcv.e(exc3, "");
|
|
C14957gcv.e(exc2, "");
|
|
if (exc3 != exc2) {
|
|
C14887gbC.c.d(exc3, exc2);
|
|
}
|
|
}
|
|
return exc;
|
|
}
|
|
|
|
public static final int indexOf(String[] strArr, String str, Comparator<String> comparator) {
|
|
C14957gcv.e(strArr, "");
|
|
C14957gcv.e(str, "");
|
|
C14957gcv.e(comparator, "");
|
|
int length = strArr.length;
|
|
for (int i = 0; i < length; i++) {
|
|
if (comparator.compare(strArr[i], str) == 0) {
|
|
return i;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
public static final <T> List<T> filterList(Iterable<? extends T> iterable, InterfaceC14894gbR<? super T, Boolean> interfaceC14894gbR) {
|
|
C14957gcv.e(iterable, "");
|
|
C14957gcv.e(interfaceC14894gbR, "");
|
|
ArrayList arrayList = C14851gaI.c;
|
|
for (T t : iterable) {
|
|
if (interfaceC14894gbR.invoke(t).booleanValue()) {
|
|
if (arrayList.isEmpty()) {
|
|
arrayList = new ArrayList();
|
|
}
|
|
gcQ.b(arrayList).add(t);
|
|
}
|
|
}
|
|
return arrayList;
|
|
}
|
|
|
|
public static final int skipAll(C15111ghZ c15111ghZ, byte b) {
|
|
C14957gcv.e(c15111ghZ, "");
|
|
int i = 0;
|
|
while (c15111ghZ.c != 0 && c15111ghZ.d(0L) == b) {
|
|
i++;
|
|
c15111ghZ.f();
|
|
}
|
|
return i;
|
|
}
|
|
|
|
/* JADX INFO: Access modifiers changed from: private */
|
|
/* renamed from: asFactory$lambda-8, reason: not valid java name */
|
|
public static final EventListener m492asFactory$lambda8(EventListener eventListener, Call call) {
|
|
C14957gcv.e(eventListener, "");
|
|
C14957gcv.e(call, "");
|
|
return eventListener;
|
|
}
|
|
}
|