315 lines
9.9 KiB
Java
315 lines
9.9 KiB
Java
package retrofit2;
|
|
|
|
import a.AbstractC0105a;
|
|
import e3.A;
|
|
import e3.F;
|
|
import e3.I;
|
|
import e3.InterfaceC0318d;
|
|
import e3.InterfaceC0319e;
|
|
import e3.InterfaceC0320f;
|
|
import e3.N;
|
|
import e3.O;
|
|
import e3.T;
|
|
import i3.j;
|
|
import java.io.IOException;
|
|
import java.util.Objects;
|
|
import kotlin.jvm.internal.Intrinsics;
|
|
import r3.C0576h;
|
|
import r3.InterfaceC0578j;
|
|
import r3.K;
|
|
import r3.p;
|
|
|
|
/* JADX INFO: Access modifiers changed from: package-private */
|
|
/* loaded from: classes3.dex */
|
|
public final class OkHttpCall<T> implements Call<T> {
|
|
private final Object[] args;
|
|
private final InterfaceC0318d callFactory;
|
|
private volatile boolean canceled;
|
|
private Throwable creationFailure;
|
|
private boolean executed;
|
|
private InterfaceC0319e rawCall;
|
|
private final RequestFactory requestFactory;
|
|
private final Converter<T, T> responseConverter;
|
|
|
|
/* loaded from: classes3.dex */
|
|
public static final class ExceptionCatchingResponseBody extends T {
|
|
private final T delegate;
|
|
private final InterfaceC0578j delegateSource;
|
|
IOException thrownException;
|
|
|
|
public ExceptionCatchingResponseBody(T t2) {
|
|
this.delegate = t2;
|
|
this.delegateSource = AbstractC0105a.d(new p(t2.source()) { // from class: retrofit2.OkHttpCall.ExceptionCatchingResponseBody.1
|
|
@Override // r3.p, r3.I
|
|
public long read(C0576h c0576h, long j4) throws IOException {
|
|
try {
|
|
return super.read(c0576h, j4);
|
|
} catch (IOException e4) {
|
|
ExceptionCatchingResponseBody.this.thrownException = e4;
|
|
throw e4;
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
@Override // e3.T, java.io.Closeable, java.lang.AutoCloseable
|
|
public void close() {
|
|
this.delegate.close();
|
|
}
|
|
|
|
@Override // e3.T
|
|
public long contentLength() {
|
|
return this.delegate.contentLength();
|
|
}
|
|
|
|
@Override // e3.T
|
|
public A contentType() {
|
|
return this.delegate.contentType();
|
|
}
|
|
|
|
@Override // e3.T
|
|
public InterfaceC0578j source() {
|
|
return this.delegateSource;
|
|
}
|
|
|
|
public void throwIfCaught() throws IOException {
|
|
IOException iOException = this.thrownException;
|
|
if (iOException != null) {
|
|
throw iOException;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* loaded from: classes3.dex */
|
|
public static final class NoContentResponseBody extends T {
|
|
private final long contentLength;
|
|
private final A contentType;
|
|
|
|
public NoContentResponseBody(A a2, long j4) {
|
|
this.contentType = a2;
|
|
this.contentLength = j4;
|
|
}
|
|
|
|
@Override // e3.T
|
|
public long contentLength() {
|
|
return this.contentLength;
|
|
}
|
|
|
|
@Override // e3.T
|
|
public A contentType() {
|
|
return this.contentType;
|
|
}
|
|
|
|
@Override // e3.T
|
|
public InterfaceC0578j source() {
|
|
throw new IllegalStateException("Cannot read raw response body of a converted body.");
|
|
}
|
|
}
|
|
|
|
public OkHttpCall(RequestFactory requestFactory, Object[] objArr, InterfaceC0318d interfaceC0318d, Converter<T, T> converter) {
|
|
this.requestFactory = requestFactory;
|
|
this.args = objArr;
|
|
this.callFactory = interfaceC0318d;
|
|
this.responseConverter = converter;
|
|
}
|
|
|
|
private InterfaceC0319e createRawCall() throws IOException {
|
|
InterfaceC0318d interfaceC0318d = this.callFactory;
|
|
I request = this.requestFactory.create(this.args);
|
|
F f2 = (F) interfaceC0318d;
|
|
f2.getClass();
|
|
Intrinsics.checkNotNullParameter(request, "request");
|
|
return new j(f2, request);
|
|
}
|
|
|
|
private InterfaceC0319e getRawCall() throws IOException {
|
|
InterfaceC0319e interfaceC0319e = this.rawCall;
|
|
if (interfaceC0319e != null) {
|
|
return interfaceC0319e;
|
|
}
|
|
Throwable th = this.creationFailure;
|
|
if (th != null) {
|
|
if (th instanceof IOException) {
|
|
throw ((IOException) th);
|
|
}
|
|
if (th instanceof RuntimeException) {
|
|
throw ((RuntimeException) th);
|
|
}
|
|
throw ((Error) th);
|
|
}
|
|
try {
|
|
InterfaceC0319e createRawCall = createRawCall();
|
|
this.rawCall = createRawCall;
|
|
return createRawCall;
|
|
} catch (IOException | Error | RuntimeException e4) {
|
|
Utils.throwIfFatal(e4);
|
|
this.creationFailure = e4;
|
|
throw e4;
|
|
}
|
|
}
|
|
|
|
@Override // retrofit2.Call
|
|
public void cancel() {
|
|
InterfaceC0319e interfaceC0319e;
|
|
this.canceled = true;
|
|
synchronized (this) {
|
|
interfaceC0319e = this.rawCall;
|
|
}
|
|
if (interfaceC0319e != null) {
|
|
((j) interfaceC0319e).cancel();
|
|
}
|
|
}
|
|
|
|
@Override // retrofit2.Call
|
|
public void enqueue(final Callback<T> callback) {
|
|
InterfaceC0319e interfaceC0319e;
|
|
Throwable th;
|
|
Objects.requireNonNull(callback, "callback == null");
|
|
synchronized (this) {
|
|
try {
|
|
if (this.executed) {
|
|
throw new IllegalStateException("Already executed.");
|
|
}
|
|
this.executed = true;
|
|
interfaceC0319e = this.rawCall;
|
|
th = this.creationFailure;
|
|
if (interfaceC0319e == null && th == null) {
|
|
try {
|
|
InterfaceC0319e createRawCall = createRawCall();
|
|
this.rawCall = createRawCall;
|
|
interfaceC0319e = createRawCall;
|
|
} catch (Throwable th2) {
|
|
th = th2;
|
|
Utils.throwIfFatal(th);
|
|
this.creationFailure = th;
|
|
}
|
|
}
|
|
} catch (Throwable th3) {
|
|
throw th3;
|
|
}
|
|
}
|
|
if (th != null) {
|
|
callback.onFailure(this, th);
|
|
return;
|
|
}
|
|
if (this.canceled) {
|
|
((j) interfaceC0319e).cancel();
|
|
}
|
|
((j) interfaceC0319e).d(new InterfaceC0320f() { // from class: retrofit2.OkHttpCall.1
|
|
private void callFailure(Throwable th4) {
|
|
try {
|
|
callback.onFailure(OkHttpCall.this, th4);
|
|
} catch (Throwable th5) {
|
|
Utils.throwIfFatal(th5);
|
|
th5.printStackTrace();
|
|
}
|
|
}
|
|
|
|
@Override // e3.InterfaceC0320f
|
|
public void onFailure(InterfaceC0319e interfaceC0319e2, IOException iOException) {
|
|
callFailure(iOException);
|
|
}
|
|
|
|
@Override // e3.InterfaceC0320f
|
|
public void onResponse(InterfaceC0319e interfaceC0319e2, O o4) {
|
|
try {
|
|
try {
|
|
callback.onResponse(OkHttpCall.this, OkHttpCall.this.parseResponse(o4));
|
|
} catch (Throwable th4) {
|
|
Utils.throwIfFatal(th4);
|
|
th4.printStackTrace();
|
|
}
|
|
} catch (Throwable th5) {
|
|
Utils.throwIfFatal(th5);
|
|
callFailure(th5);
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
@Override // retrofit2.Call
|
|
public Response<T> execute() throws IOException {
|
|
InterfaceC0319e rawCall;
|
|
synchronized (this) {
|
|
if (this.executed) {
|
|
throw new IllegalStateException("Already executed.");
|
|
}
|
|
this.executed = true;
|
|
rawCall = getRawCall();
|
|
}
|
|
if (this.canceled) {
|
|
((j) rawCall).cancel();
|
|
}
|
|
return parseResponse(((j) rawCall).e());
|
|
}
|
|
|
|
@Override // retrofit2.Call
|
|
public boolean isCanceled() {
|
|
boolean z3 = true;
|
|
if (this.canceled) {
|
|
return true;
|
|
}
|
|
synchronized (this) {
|
|
InterfaceC0319e interfaceC0319e = this.rawCall;
|
|
if (interfaceC0319e == null || !((j) interfaceC0319e).f6871n) {
|
|
z3 = false;
|
|
}
|
|
}
|
|
return z3;
|
|
}
|
|
|
|
@Override // retrofit2.Call
|
|
public synchronized boolean isExecuted() {
|
|
return this.executed;
|
|
}
|
|
|
|
public Response<T> parseResponse(O o4) throws IOException {
|
|
T t2 = o4.f6297g;
|
|
N s4 = o4.s();
|
|
s4.f6286g = new NoContentResponseBody(t2.contentType(), t2.contentLength());
|
|
O a2 = s4.a();
|
|
int i = a2.f6294d;
|
|
if (i < 200 || i >= 300) {
|
|
try {
|
|
return Response.error(Utils.buffer(t2), a2);
|
|
} finally {
|
|
t2.close();
|
|
}
|
|
}
|
|
if (i == 204 || i == 205) {
|
|
t2.close();
|
|
return Response.success((Object) null, a2);
|
|
}
|
|
ExceptionCatchingResponseBody exceptionCatchingResponseBody = new ExceptionCatchingResponseBody(t2);
|
|
try {
|
|
return Response.success(this.responseConverter.convert(exceptionCatchingResponseBody), a2);
|
|
} catch (RuntimeException e4) {
|
|
exceptionCatchingResponseBody.throwIfCaught();
|
|
throw e4;
|
|
}
|
|
}
|
|
|
|
@Override // retrofit2.Call
|
|
public synchronized I request() {
|
|
try {
|
|
} catch (IOException e4) {
|
|
throw new RuntimeException("Unable to create request.", e4);
|
|
}
|
|
return ((j) getRawCall()).f6861b;
|
|
}
|
|
|
|
@Override // retrofit2.Call
|
|
public synchronized K timeout() {
|
|
try {
|
|
} catch (IOException e4) {
|
|
throw new RuntimeException("Unable to create call.", e4);
|
|
}
|
|
return ((j) getRawCall()).f6863d;
|
|
}
|
|
|
|
@Override // retrofit2.Call
|
|
public OkHttpCall<T> clone() {
|
|
return new OkHttpCall<>(this.requestFactory, this.args, this.callFactory, this.responseConverter);
|
|
}
|
|
}
|