Initial commit

sources/retrofit2/BuiltInConverters.java

@@ -0,0 +1,100 @@
+package retrofit2;
+
+import java.io.IOException;
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Type;
+import okhttp3.RequestBody;
+import okhttp3.ResponseBody;
+import retrofit2.Converter;
+import retrofit2.http.Streaming;
+
+/* loaded from: classes2.dex */
+final class BuiltInConverters extends Converter.Factory {
+
+    static final class BufferingResponseBodyConverter implements Converter<ResponseBody, ResponseBody> {
+        static final BufferingResponseBodyConverter INSTANCE = new BufferingResponseBodyConverter();
+
+        BufferingResponseBodyConverter() {
+        }
+
+        @Override // retrofit2.Converter
+        public ResponseBody convert(ResponseBody responseBody) throws IOException {
+            try {
+                return Utils.buffer(responseBody);
+            } finally {
+                responseBody.close();
+            }
+        }
+    }
+
+    static final class RequestBodyConverter implements Converter<RequestBody, RequestBody> {
+        static final RequestBodyConverter INSTANCE = new RequestBodyConverter();
+
+        RequestBodyConverter() {
+        }
+
+        @Override // retrofit2.Converter
+        public RequestBody convert(RequestBody requestBody) {
+            return requestBody;
+        }
+    }
+
+    static final class StreamingResponseBodyConverter implements Converter<ResponseBody, ResponseBody> {
+        static final StreamingResponseBodyConverter INSTANCE = new StreamingResponseBodyConverter();
+
+        StreamingResponseBodyConverter() {
+        }
+
+        @Override // retrofit2.Converter
+        public ResponseBody convert(ResponseBody responseBody) {
+            return responseBody;
+        }
+    }
+
+    static final class ToStringConverter implements Converter<Object, String> {
+        static final ToStringConverter INSTANCE = new ToStringConverter();
+
+        ToStringConverter() {
+        }
+
+        @Override // retrofit2.Converter
+        public String convert(Object obj) {
+            return obj.toString();
+        }
+    }
+
+    static final class VoidResponseBodyConverter implements Converter<ResponseBody, Void> {
+        static final VoidResponseBodyConverter INSTANCE = new VoidResponseBodyConverter();
+
+        VoidResponseBodyConverter() {
+        }
+
+        @Override // retrofit2.Converter
+        public Void convert(ResponseBody responseBody) {
+            responseBody.close();
+            return null;
+        }
+    }
+
+    BuiltInConverters() {
+    }
+
+    @Override // retrofit2.Converter.Factory
+    public Converter<?, RequestBody> requestBodyConverter(Type type, Annotation[] annotationArr, Annotation[] annotationArr2, Retrofit retrofit) {
+        if (RequestBody.class.isAssignableFrom(Utils.getRawType(type))) {
+            return RequestBodyConverter.INSTANCE;
+        }
+        return null;
+    }
+
+    @Override // retrofit2.Converter.Factory
+    public Converter<ResponseBody, ?> responseBodyConverter(Type type, Annotation[] annotationArr, Retrofit retrofit) {
+        if (type == ResponseBody.class) {
+            return Utils.isAnnotationPresent(annotationArr, Streaming.class) ? StreamingResponseBodyConverter.INSTANCE : BufferingResponseBodyConverter.INSTANCE;
+        }
+        if (type == Void.class) {
+            return VoidResponseBodyConverter.INSTANCE;
+        }
+        return null;
+    }
+}

sources/retrofit2/Call.java

@@ -0,0 +1,22 @@
+package retrofit2;
+
+import java.io.IOException;
+import okhttp3.Request;
+
+/* loaded from: classes2.dex */
+public interface Call<T> extends Cloneable {
+    void cancel();
+
+    /* renamed from: clone */
+    Call<T> mo21clone();
+
+    void enqueue(Callback<T> callback);
+
+    Response<T> execute() throws IOException;
+
+    boolean isCanceled();
+
+    boolean isExecuted();
+
+    Request request();
+}

sources/retrofit2/CallAdapter.java

@@ -0,0 +1,25 @@
+package retrofit2;
+
+import java.lang.annotation.Annotation;
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Type;
+
+/* loaded from: classes2.dex */
+public interface CallAdapter<R, T> {
+
+    public static abstract class Factory {
+        protected static Type getParameterUpperBound(int i, ParameterizedType parameterizedType) {
+            return Utils.getParameterUpperBound(i, parameterizedType);
+        }
+
+        protected static Class<?> getRawType(Type type) {
+            return Utils.getRawType(type);
+        }
+
+        public abstract CallAdapter<?, ?> get(Type type, Annotation[] annotationArr, Retrofit retrofit);
+    }
+
+    T adapt(Call<R> call);
+
+    Type responseType();
+}

sources/retrofit2/Callback.java

@@ -0,0 +1,8 @@
+package retrofit2;
+
+/* loaded from: classes2.dex */
+public interface Callback<T> {
+    void onFailure(Call<T> call, Throwable th);
+
+    void onResponse(Call<T> call, Response<T> response);
+}

sources/retrofit2/Converter.java

@@ -0,0 +1,36 @@
+package retrofit2;
+
+import java.io.IOException;
+import java.lang.annotation.Annotation;
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Type;
+import okhttp3.RequestBody;
+import okhttp3.ResponseBody;
+
+/* loaded from: classes2.dex */
+public interface Converter<F, T> {
+
+    public static abstract class Factory {
+        protected static Type getParameterUpperBound(int i, ParameterizedType parameterizedType) {
+            return Utils.getParameterUpperBound(i, parameterizedType);
+        }
+
+        protected static Class<?> getRawType(Type type) {
+            return Utils.getRawType(type);
+        }
+
+        public Converter<?, RequestBody> requestBodyConverter(Type type, Annotation[] annotationArr, Annotation[] annotationArr2, Retrofit retrofit) {
+            return null;
+        }
+
+        public Converter<ResponseBody, ?> responseBodyConverter(Type type, Annotation[] annotationArr, Retrofit retrofit) {
+            return null;
+        }
+
+        public Converter<?, String> stringConverter(Type type, Annotation[] annotationArr, Retrofit retrofit) {
+            return null;
+        }
+    }
+
+    T convert(F f) throws IOException;
+}

sources/retrofit2/DefaultCallAdapterFactory.java

@@ -0,0 +1,32 @@
+package retrofit2;
+
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Type;
+import retrofit2.CallAdapter;
+
+/* loaded from: classes2.dex */
+final class DefaultCallAdapterFactory extends CallAdapter.Factory {
+    static final CallAdapter.Factory INSTANCE = new DefaultCallAdapterFactory();
+
+    DefaultCallAdapterFactory() {
+    }
+
+    @Override // retrofit2.CallAdapter.Factory
+    public CallAdapter<?, ?> get(Type type, Annotation[] annotationArr, Retrofit retrofit) {
+        if (CallAdapter.Factory.getRawType(type) != Call.class) {
+            return null;
+        }
+        final Type callResponseType = Utils.getCallResponseType(type);
+        return new CallAdapter<Object, Call<?>>() { // from class: retrofit2.DefaultCallAdapterFactory.1
+            @Override // retrofit2.CallAdapter
+            public Call<?> adapt(Call<Object> call) {
+                return call;
+            }
+
+            @Override // retrofit2.CallAdapter
+            public Type responseType() {
+                return callResponseType;
+            }
+        };
+    }
+}

sources/retrofit2/ExecutorCallAdapterFactory.java

@@ -0,0 +1,109 @@
+package retrofit2;
+
+import java.io.IOException;
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Type;
+import java.util.concurrent.Executor;
+import okhttp3.Request;
+import retrofit2.CallAdapter;
+
+/* loaded from: classes2.dex */
+final class ExecutorCallAdapterFactory extends CallAdapter.Factory {
+    final Executor callbackExecutor;
+
+    static final class ExecutorCallbackCall<T> implements Call<T> {
+        final Executor callbackExecutor;
+        final Call<T> delegate;
+
+        ExecutorCallbackCall(Executor executor, Call<T> call) {
+            this.callbackExecutor = executor;
+            this.delegate = call;
+        }
+
+        @Override // retrofit2.Call
+        public void cancel() {
+            this.delegate.cancel();
+        }
+
+        @Override // retrofit2.Call
+        public void enqueue(final Callback<T> callback) {
+            Utils.checkNotNull(callback, "callback == null");
+            this.delegate.enqueue(new Callback<T>() { // from class: retrofit2.ExecutorCallAdapterFactory.ExecutorCallbackCall.1
+                @Override // retrofit2.Callback
+                public void onFailure(Call<T> call, final Throwable th) {
+                    ExecutorCallbackCall.this.callbackExecutor.execute(new Runnable() { // from class: retrofit2.ExecutorCallAdapterFactory.ExecutorCallbackCall.1.2
+                        @Override // java.lang.Runnable
+                        public void run() {
+                            AnonymousClass1 anonymousClass1 = AnonymousClass1.this;
+                            callback.onFailure(ExecutorCallbackCall.this, th);
+                        }
+                    });
+                }
+
+                @Override // retrofit2.Callback
+                public void onResponse(Call<T> call, final Response<T> response) {
+                    ExecutorCallbackCall.this.callbackExecutor.execute(new Runnable() { // from class: retrofit2.ExecutorCallAdapterFactory.ExecutorCallbackCall.1.1
+                        @Override // java.lang.Runnable
+                        public void run() {
+                            if (ExecutorCallbackCall.this.delegate.isCanceled()) {
+                                AnonymousClass1 anonymousClass1 = AnonymousClass1.this;
+                                callback.onFailure(ExecutorCallbackCall.this, new IOException("Canceled"));
+                            } else {
+                                AnonymousClass1 anonymousClass12 = AnonymousClass1.this;
+                                callback.onResponse(ExecutorCallbackCall.this, response);
+                            }
+                        }
+                    });
+                }
+            });
+        }
+
+        @Override // retrofit2.Call
+        public Response<T> execute() throws IOException {
+            return this.delegate.execute();
+        }
+
+        @Override // retrofit2.Call
+        public boolean isCanceled() {
+            return this.delegate.isCanceled();
+        }
+
+        @Override // retrofit2.Call
+        public boolean isExecuted() {
+            return this.delegate.isExecuted();
+        }
+
+        @Override // retrofit2.Call
+        public Request request() {
+            return this.delegate.request();
+        }
+
+        @Override // retrofit2.Call
+        public Call<T> clone() {
+            return new ExecutorCallbackCall(this.callbackExecutor, this.delegate.clone());
+        }
+    }
+
+    ExecutorCallAdapterFactory(Executor executor) {
+        this.callbackExecutor = executor;
+    }
+
+    @Override // retrofit2.CallAdapter.Factory
+    public CallAdapter<?, ?> get(Type type, Annotation[] annotationArr, Retrofit retrofit) {
+        if (CallAdapter.Factory.getRawType(type) != Call.class) {
+            return null;
+        }
+        final Type callResponseType = Utils.getCallResponseType(type);
+        return new CallAdapter<Object, Call<?>>() { // from class: retrofit2.ExecutorCallAdapterFactory.1
+            @Override // retrofit2.CallAdapter
+            public Type responseType() {
+                return callResponseType;
+            }
+
+            @Override // retrofit2.CallAdapter
+            public Call<?> adapt(Call<Object> call) {
+                return new ExecutorCallbackCall(ExecutorCallAdapterFactory.this.callbackExecutor, call);
+            }
+        };
+    }
+}

sources/retrofit2/HttpException.java

@@ -0,0 +1,32 @@
+package retrofit2;
+
+/* loaded from: classes2.dex */
+public class HttpException extends RuntimeException {
+    private final int code;
+    private final String message;
+    private final transient Response<?> response;
+
+    public HttpException(Response<?> response) {
+        super(getMessage(response));
+        this.code = response.code();
+        this.message = response.message();
+        this.response = response;
+    }
+
+    private static String getMessage(Response<?> response) {
+        Utils.checkNotNull(response, "response == null");
+        return "HTTP " + response.code() + " " + response.message();
+    }
+
+    public int code() {
+        return this.code;
+    }
+
+    public String message() {
+        return this.message;
+    }
+
+    public Response<?> response() {
+        return this.response;
+    }
+}

sources/retrofit2/OkHttpCall.java

@@ -0,0 +1,294 @@
+package retrofit2;
+
+import java.io.IOException;
+import okhttp3.MediaType;
+import okhttp3.Request;
+import okhttp3.ResponseBody;
+import okio.Buffer;
+import okio.BufferedSource;
+import okio.ForwardingSource;
+import okio.Okio;
+
+/* loaded from: classes2.dex */
+final class OkHttpCall<T> implements Call<T> {
+    private final Object[] args;
+    private volatile boolean canceled;
+    private Throwable creationFailure;
+    private boolean executed;
+    private okhttp3.Call rawCall;
+    private final ServiceMethod<T, ?> serviceMethod;
+
+    static final class ExceptionCatchingRequestBody extends ResponseBody {
+        private final ResponseBody delegate;
+        IOException thrownException;
+
+        ExceptionCatchingRequestBody(ResponseBody responseBody) {
+            this.delegate = responseBody;
+        }
+
+        @Override // okhttp3.ResponseBody, java.io.Closeable, java.lang.AutoCloseable
+        public void close() {
+            this.delegate.close();
+        }
+
+        @Override // okhttp3.ResponseBody
+        public long contentLength() {
+            return this.delegate.contentLength();
+        }
+
+        @Override // okhttp3.ResponseBody
+        public MediaType contentType() {
+            return this.delegate.contentType();
+        }
+
+        @Override // okhttp3.ResponseBody
+        public BufferedSource source() {
+            return Okio.buffer(new ForwardingSource(this.delegate.source()) { // from class: retrofit2.OkHttpCall.ExceptionCatchingRequestBody.1
+                @Override // okio.ForwardingSource, okio.Source
+                public long read(Buffer buffer, long j) throws IOException {
+                    try {
+                        return super.read(buffer, j);
+                    } catch (IOException e) {
+                        ExceptionCatchingRequestBody.this.thrownException = e;
+                        throw e;
+                    }
+                }
+            });
+        }
+
+        void throwIfCaught() throws IOException {
+            IOException iOException = this.thrownException;
+            if (iOException != null) {
+                throw iOException;
+            }
+        }
+    }
+
+    static final class NoContentResponseBody extends ResponseBody {
+        private final long contentLength;
+        private final MediaType contentType;
+
+        NoContentResponseBody(MediaType mediaType, long j) {
+            this.contentType = mediaType;
+            this.contentLength = j;
+        }
+
+        @Override // okhttp3.ResponseBody
+        public long contentLength() {
+            return this.contentLength;
+        }
+
+        @Override // okhttp3.ResponseBody
+        public MediaType contentType() {
+            return this.contentType;
+        }
+
+        @Override // okhttp3.ResponseBody
+        public BufferedSource source() {
+            throw new IllegalStateException("Cannot read raw response body of a converted body.");
+        }
+    }
+
+    OkHttpCall(ServiceMethod<T, ?> serviceMethod, Object[] objArr) {
+        this.serviceMethod = serviceMethod;
+        this.args = objArr;
+    }
+
+    private okhttp3.Call createRawCall() throws IOException {
+        okhttp3.Call call = this.serviceMethod.toCall(this.args);
+        if (call != null) {
+            return call;
+        }
+        throw new NullPointerException("Call.Factory returned null.");
+    }
+
+    @Override // retrofit2.Call
+    public void cancel() {
+        okhttp3.Call call;
+        this.canceled = true;
+        synchronized (this) {
+            call = this.rawCall;
+        }
+        if (call != null) {
+            call.cancel();
+        }
+    }
+
+    @Override // retrofit2.Call
+    public void enqueue(final Callback<T> callback) {
+        okhttp3.Call call;
+        Throwable th;
+        Utils.checkNotNull(callback, "callback == null");
+        synchronized (this) {
+            if (this.executed) {
+                throw new IllegalStateException("Already executed.");
+            }
+            this.executed = true;
+            call = this.rawCall;
+            th = this.creationFailure;
+            if (call == null && th == null) {
+                try {
+                    okhttp3.Call createRawCall = createRawCall();
+                    this.rawCall = createRawCall;
+                    call = createRawCall;
+                } catch (Throwable th2) {
+                    th = th2;
+                    Utils.throwIfFatal(th);
+                    this.creationFailure = th;
+                }
+            }
+        }
+        if (th != null) {
+            callback.onFailure(this, th);
+            return;
+        }
+        if (this.canceled) {
+            call.cancel();
+        }
+        call.enqueue(new okhttp3.Callback() { // from class: retrofit2.OkHttpCall.1
+            private void callFailure(Throwable th3) {
+                try {
+                    callback.onFailure(OkHttpCall.this, th3);
+                } catch (Throwable th4) {
+                    th4.printStackTrace();
+                }
+            }
+
+            @Override // okhttp3.Callback
+            public void onFailure(okhttp3.Call call2, IOException iOException) {
+                callFailure(iOException);
+            }
+
+            @Override // okhttp3.Callback
+            public void onResponse(okhttp3.Call call2, okhttp3.Response response) {
+                try {
+                    try {
+                        callback.onResponse(OkHttpCall.this, OkHttpCall.this.parseResponse(response));
+                    } catch (Throwable th3) {
+                        th3.printStackTrace();
+                    }
+                } catch (Throwable th4) {
+                    callFailure(th4);
+                }
+            }
+        });
+    }
+
+    @Override // retrofit2.Call
+    public Response<T> execute() throws IOException {
+        okhttp3.Call call;
+        synchronized (this) {
+            if (this.executed) {
+                throw new IllegalStateException("Already executed.");
+            }
+            this.executed = true;
+            if (this.creationFailure != null) {
+                if (this.creationFailure instanceof IOException) {
+                    throw ((IOException) this.creationFailure);
+                }
+                if (this.creationFailure instanceof RuntimeException) {
+                    throw ((RuntimeException) this.creationFailure);
+                }
+                throw ((Error) this.creationFailure);
+            }
+            call = this.rawCall;
+            if (call == null) {
+                try {
+                    call = createRawCall();
+                    this.rawCall = call;
+                } catch (IOException | Error | RuntimeException e) {
+                    Utils.throwIfFatal(e);
+                    this.creationFailure = e;
+                    throw e;
+                }
+            }
+        }
+        if (this.canceled) {
+            call.cancel();
+        }
+        return parseResponse(call.execute());
+    }
+
+    @Override // retrofit2.Call
+    public boolean isCanceled() {
+        boolean z = true;
+        if (this.canceled) {
+            return true;
+        }
+        synchronized (this) {
+            if (this.rawCall == null || !this.rawCall.isCanceled()) {
+                z = false;
+            }
+        }
+        return z;
+    }
+
+    @Override // retrofit2.Call
+    public synchronized boolean isExecuted() {
+        return this.executed;
+    }
+
+    Response<T> parseResponse(okhttp3.Response response) throws IOException {
+        ResponseBody body = response.body();
+        okhttp3.Response build = response.newBuilder().body(new NoContentResponseBody(body.contentType(), body.contentLength())).build();
+        int code = build.code();
+        if (code < 200 || code >= 300) {
+            try {
+                return Response.error(Utils.buffer(body), build);
+            } finally {
+                body.close();
+            }
+        }
+        if (code == 204 || code == 205) {
+            body.close();
+            return Response.success((Object) null, build);
+        }
+        ExceptionCatchingRequestBody exceptionCatchingRequestBody = new ExceptionCatchingRequestBody(body);
+        try {
+            return Response.success(this.serviceMethod.toResponse(exceptionCatchingRequestBody), build);
+        } catch (RuntimeException e) {
+            exceptionCatchingRequestBody.throwIfCaught();
+            throw e;
+        }
+    }
+
+    @Override // retrofit2.Call
+    public synchronized Request request() {
+        okhttp3.Call call = this.rawCall;
+        if (call != null) {
+            return call.request();
+        }
+        if (this.creationFailure != null) {
+            if (this.creationFailure instanceof IOException) {
+                throw new RuntimeException("Unable to create request.", this.creationFailure);
+            }
+            if (this.creationFailure instanceof RuntimeException) {
+                throw ((RuntimeException) this.creationFailure);
+            }
+            throw ((Error) this.creationFailure);
+        }
+        try {
+            okhttp3.Call createRawCall = createRawCall();
+            this.rawCall = createRawCall;
+            return createRawCall.request();
+        } catch (IOException e) {
+            this.creationFailure = e;
+            throw new RuntimeException("Unable to create request.", e);
+        } catch (Error e2) {
+            e = e2;
+            Utils.throwIfFatal(e);
+            this.creationFailure = e;
+            throw e;
+        } catch (RuntimeException e3) {
+            e = e3;
+            Utils.throwIfFatal(e);
+            this.creationFailure = e;
+            throw e;
+        }
+    }
+
+    @Override // retrofit2.Call
+    public OkHttpCall<T> clone() {
+        return new OkHttpCall<>(this.serviceMethod, this.args);
+    }
+}

sources/retrofit2/ParameterHandler.java

@@ -0,0 +1,340 @@
+package retrofit2;
+
+import java.io.IOException;
+import java.lang.reflect.Array;
+import java.util.Iterator;
+import java.util.Map;
+import okhttp3.Headers;
+import okhttp3.MultipartBody;
+import okhttp3.RequestBody;
+
+/* loaded from: classes2.dex */
+abstract class ParameterHandler<T> {
+
+    static final class Body<T> extends ParameterHandler<T> {
+        private final Converter<T, RequestBody> converter;
+
+        Body(Converter<T, RequestBody> converter) {
+            this.converter = converter;
+        }
+
+        @Override // retrofit2.ParameterHandler
+        void apply(RequestBuilder requestBuilder, T t) {
+            if (t == null) {
+                throw new IllegalArgumentException("Body parameter value must not be null.");
+            }
+            try {
+                requestBuilder.setBody(this.converter.convert(t));
+            } catch (IOException e) {
+                throw new RuntimeException("Unable to convert " + t + " to RequestBody", e);
+            }
+        }
+    }
+
+    static final class Field<T> extends ParameterHandler<T> {
+        private final boolean encoded;
+        private final String name;
+        private final Converter<T, String> valueConverter;
+
+        Field(String str, Converter<T, String> converter, boolean z) {
+            this.name = (String) Utils.checkNotNull(str, "name == null");
+            this.valueConverter = converter;
+            this.encoded = z;
+        }
+
+        @Override // retrofit2.ParameterHandler
+        void apply(RequestBuilder requestBuilder, T t) throws IOException {
+            String convert;
+            if (t == null || (convert = this.valueConverter.convert(t)) == null) {
+                return;
+            }
+            requestBuilder.addFormField(this.name, convert, this.encoded);
+        }
+    }
+
+    static final class FieldMap<T> extends ParameterHandler<Map<String, T>> {
+        private final boolean encoded;
+        private final Converter<T, String> valueConverter;
+
+        FieldMap(Converter<T, String> converter, boolean z) {
+            this.valueConverter = converter;
+            this.encoded = z;
+        }
+
+        /* JADX INFO: Access modifiers changed from: package-private */
+        @Override // retrofit2.ParameterHandler
+        public void apply(RequestBuilder requestBuilder, Map<String, T> map) throws IOException {
+            if (map == null) {
+                throw new IllegalArgumentException("Field map was null.");
+            }
+            for (Map.Entry<String, T> entry : map.entrySet()) {
+                String key = entry.getKey();
+                if (key == null) {
+                    throw new IllegalArgumentException("Field map contained null key.");
+                }
+                T value = entry.getValue();
+                if (value == null) {
+                    throw new IllegalArgumentException("Field map contained null value for key '" + key + "'.");
+                }
+                String convert = this.valueConverter.convert(value);
+                if (convert == null) {
+                    throw new IllegalArgumentException("Field map value '" + value + "' converted to null by " + this.valueConverter.getClass().getName() + " for key '" + key + "'.");
+                }
+                requestBuilder.addFormField(key, convert, this.encoded);
+            }
+        }
+    }
+
+    static final class Header<T> extends ParameterHandler<T> {
+        private final String name;
+        private final Converter<T, String> valueConverter;
+
+        Header(String str, Converter<T, String> converter) {
+            this.name = (String) Utils.checkNotNull(str, "name == null");
+            this.valueConverter = converter;
+        }
+
+        @Override // retrofit2.ParameterHandler
+        void apply(RequestBuilder requestBuilder, T t) throws IOException {
+            String convert;
+            if (t == null || (convert = this.valueConverter.convert(t)) == null) {
+                return;
+            }
+            requestBuilder.addHeader(this.name, convert);
+        }
+    }
+
+    static final class HeaderMap<T> extends ParameterHandler<Map<String, T>> {
+        private final Converter<T, String> valueConverter;
+
+        HeaderMap(Converter<T, String> converter) {
+            this.valueConverter = converter;
+        }
+
+        /* JADX INFO: Access modifiers changed from: package-private */
+        @Override // retrofit2.ParameterHandler
+        public void apply(RequestBuilder requestBuilder, Map<String, T> map) throws IOException {
+            if (map == null) {
+                throw new IllegalArgumentException("Header map was null.");
+            }
+            for (Map.Entry<String, T> entry : map.entrySet()) {
+                String key = entry.getKey();
+                if (key == null) {
+                    throw new IllegalArgumentException("Header map contained null key.");
+                }
+                T value = entry.getValue();
+                if (value == null) {
+                    throw new IllegalArgumentException("Header map contained null value for key '" + key + "'.");
+                }
+                requestBuilder.addHeader(key, this.valueConverter.convert(value));
+            }
+        }
+    }
+
+    static final class Part<T> extends ParameterHandler<T> {
+        private final Converter<T, RequestBody> converter;
+        private final Headers headers;
+
+        Part(Headers headers, Converter<T, RequestBody> converter) {
+            this.headers = headers;
+            this.converter = converter;
+        }
+
+        @Override // retrofit2.ParameterHandler
+        void apply(RequestBuilder requestBuilder, T t) {
+            if (t == null) {
+                return;
+            }
+            try {
+                requestBuilder.addPart(this.headers, this.converter.convert(t));
+            } catch (IOException e) {
+                throw new RuntimeException("Unable to convert " + t + " to RequestBody", e);
+            }
+        }
+    }
+
+    static final class PartMap<T> extends ParameterHandler<Map<String, T>> {
+        private final String transferEncoding;
+        private final Converter<T, RequestBody> valueConverter;
+
+        PartMap(Converter<T, RequestBody> converter, String str) {
+            this.valueConverter = converter;
+            this.transferEncoding = str;
+        }
+
+        /* JADX INFO: Access modifiers changed from: package-private */
+        @Override // retrofit2.ParameterHandler
+        public void apply(RequestBuilder requestBuilder, Map<String, T> map) throws IOException {
+            if (map == null) {
+                throw new IllegalArgumentException("Part map was null.");
+            }
+            for (Map.Entry<String, T> entry : map.entrySet()) {
+                String key = entry.getKey();
+                if (key == null) {
+                    throw new IllegalArgumentException("Part map contained null key.");
+                }
+                T value = entry.getValue();
+                if (value == null) {
+                    throw new IllegalArgumentException("Part map contained null value for key '" + key + "'.");
+                }
+                requestBuilder.addPart(Headers.of("Content-Disposition", "form-data; name=\"" + key + "\"", "Content-Transfer-Encoding", this.transferEncoding), this.valueConverter.convert(value));
+            }
+        }
+    }
+
+    static final class Path<T> extends ParameterHandler<T> {
+        private final boolean encoded;
+        private final String name;
+        private final Converter<T, String> valueConverter;
+
+        Path(String str, Converter<T, String> converter, boolean z) {
+            this.name = (String) Utils.checkNotNull(str, "name == null");
+            this.valueConverter = converter;
+            this.encoded = z;
+        }
+
+        @Override // retrofit2.ParameterHandler
+        void apply(RequestBuilder requestBuilder, T t) throws IOException {
+            if (t != null) {
+                requestBuilder.addPathParam(this.name, this.valueConverter.convert(t), this.encoded);
+                return;
+            }
+            throw new IllegalArgumentException("Path parameter \"" + this.name + "\" value must not be null.");
+        }
+    }
+
+    static final class Query<T> extends ParameterHandler<T> {
+        private final boolean encoded;
+        private final String name;
+        private final Converter<T, String> valueConverter;
+
+        Query(String str, Converter<T, String> converter, boolean z) {
+            this.name = (String) Utils.checkNotNull(str, "name == null");
+            this.valueConverter = converter;
+            this.encoded = z;
+        }
+
+        @Override // retrofit2.ParameterHandler
+        void apply(RequestBuilder requestBuilder, T t) throws IOException {
+            String convert;
+            if (t == null || (convert = this.valueConverter.convert(t)) == null) {
+                return;
+            }
+            requestBuilder.addQueryParam(this.name, convert, this.encoded);
+        }
+    }
+
+    static final class QueryMap<T> extends ParameterHandler<Map<String, T>> {
+        private final boolean encoded;
+        private final Converter<T, String> valueConverter;
+
+        QueryMap(Converter<T, String> converter, boolean z) {
+            this.valueConverter = converter;
+            this.encoded = z;
+        }
+
+        /* JADX INFO: Access modifiers changed from: package-private */
+        @Override // retrofit2.ParameterHandler
+        public void apply(RequestBuilder requestBuilder, Map<String, T> map) throws IOException {
+            if (map == null) {
+                throw new IllegalArgumentException("Query map was null.");
+            }
+            for (Map.Entry<String, T> entry : map.entrySet()) {
+                String key = entry.getKey();
+                if (key == null) {
+                    throw new IllegalArgumentException("Query map contained null key.");
+                }
+                T value = entry.getValue();
+                if (value == null) {
+                    throw new IllegalArgumentException("Query map contained null value for key '" + key + "'.");
+                }
+                String convert = this.valueConverter.convert(value);
+                if (convert == null) {
+                    throw new IllegalArgumentException("Query map value '" + value + "' converted to null by " + this.valueConverter.getClass().getName() + " for key '" + key + "'.");
+                }
+                requestBuilder.addQueryParam(key, convert, this.encoded);
+            }
+        }
+    }
+
+    static final class QueryName<T> extends ParameterHandler<T> {
+        private final boolean encoded;
+        private final Converter<T, String> nameConverter;
+
+        QueryName(Converter<T, String> converter, boolean z) {
+            this.nameConverter = converter;
+            this.encoded = z;
+        }
+
+        @Override // retrofit2.ParameterHandler
+        void apply(RequestBuilder requestBuilder, T t) throws IOException {
+            if (t == null) {
+                return;
+            }
+            requestBuilder.addQueryParam(this.nameConverter.convert(t), null, this.encoded);
+        }
+    }
+
+    static final class RawPart extends ParameterHandler<MultipartBody.Part> {
+        static final RawPart INSTANCE = new RawPart();
+
+        private RawPart() {
+        }
+
+        /* JADX INFO: Access modifiers changed from: package-private */
+        @Override // retrofit2.ParameterHandler
+        public void apply(RequestBuilder requestBuilder, MultipartBody.Part part) {
+            if (part != null) {
+                requestBuilder.addPart(part);
+            }
+        }
+    }
+
+    static final class RelativeUrl extends ParameterHandler<Object> {
+        RelativeUrl() {
+        }
+
+        @Override // retrofit2.ParameterHandler
+        void apply(RequestBuilder requestBuilder, Object obj) {
+            Utils.checkNotNull(obj, "@Url parameter is null.");
+            requestBuilder.setRelativeUrl(obj);
+        }
+    }
+
+    ParameterHandler() {
+    }
+
+    abstract void apply(RequestBuilder requestBuilder, T t) throws IOException;
+
+    final ParameterHandler<Object> array() {
+        return new ParameterHandler<Object>() { // from class: retrofit2.ParameterHandler.2
+            /* JADX WARN: Multi-variable type inference failed */
+            @Override // retrofit2.ParameterHandler
+            void apply(RequestBuilder requestBuilder, Object obj) throws IOException {
+                if (obj == null) {
+                    return;
+                }
+                int length = Array.getLength(obj);
+                for (int i = 0; i < length; i++) {
+                    ParameterHandler.this.apply(requestBuilder, Array.get(obj, i));
+                }
+            }
+        };
+    }
+
+    final ParameterHandler<Iterable<T>> iterable() {
+        return new ParameterHandler<Iterable<T>>() { // from class: retrofit2.ParameterHandler.1
+            /* JADX INFO: Access modifiers changed from: package-private */
+            @Override // retrofit2.ParameterHandler
+            public void apply(RequestBuilder requestBuilder, Iterable<T> iterable) throws IOException {
+                if (iterable == null) {
+                    return;
+                }
+                Iterator<T> it = iterable.iterator();
+                while (it.hasNext()) {
+                    ParameterHandler.this.apply(requestBuilder, it.next());
+                }
+            }
+        };
+    }
+}

sources/retrofit2/Platform.java

@@ -0,0 +1,102 @@
+package retrofit2;
+
+import android.os.Build;
+import android.os.Handler;
+import android.os.Looper;
+import java.lang.invoke.MethodHandles;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Method;
+import java.util.concurrent.Executor;
+import retrofit2.CallAdapter;
+
+/* loaded from: classes2.dex */
+class Platform {
+    private static final Platform PLATFORM = findPlatform();
+
+    static class Android extends Platform {
+
+        static class MainThreadExecutor implements Executor {
+            private final Handler handler = new Handler(Looper.getMainLooper());
+
+            MainThreadExecutor() {
+            }
+
+            @Override // java.util.concurrent.Executor
+            public void execute(Runnable runnable) {
+                this.handler.post(runnable);
+            }
+        }
+
+        Android() {
+        }
+
+        @Override // retrofit2.Platform
+        CallAdapter.Factory defaultCallAdapterFactory(Executor executor) {
+            if (executor != null) {
+                return new ExecutorCallAdapterFactory(executor);
+            }
+            throw new AssertionError();
+        }
+
+        @Override // retrofit2.Platform
+        public Executor defaultCallbackExecutor() {
+            return new MainThreadExecutor();
+        }
+    }
+
+    static class Java8 extends Platform {
+        Java8() {
+        }
+
+        @Override // retrofit2.Platform
+        Object invokeDefaultMethod(Method method, Class<?> cls, Object obj, Object... objArr) throws Throwable {
+            Constructor declaredConstructor = MethodHandles.Lookup.class.getDeclaredConstructor(Class.class, Integer.TYPE);
+            declaredConstructor.setAccessible(true);
+            return ((MethodHandles.Lookup) declaredConstructor.newInstance(cls, -1)).unreflectSpecial(method, cls).bindTo(obj).invokeWithArguments(objArr);
+        }
+
+        @Override // retrofit2.Platform
+        boolean isDefaultMethod(Method method) {
+            return method.isDefault();
+        }
+    }
+
+    Platform() {
+    }
+
+    private static Platform findPlatform() {
+        try {
+            Class.forName("android.os.Build");
+            if (Build.VERSION.SDK_INT != 0) {
+                return new Android();
+            }
+        } catch (ClassNotFoundException unused) {
+        }
+        try {
+            Class.forName("java.util.Optional");
+            return new Java8();
+        } catch (ClassNotFoundException unused2) {
+            return new Platform();
+        }
+    }
+
+    static Platform get() {
+        return PLATFORM;
+    }
+
+    CallAdapter.Factory defaultCallAdapterFactory(Executor executor) {
+        return executor != null ? new ExecutorCallAdapterFactory(executor) : DefaultCallAdapterFactory.INSTANCE;
+    }
+
+    Executor defaultCallbackExecutor() {
+        return null;
+    }
+
+    Object invokeDefaultMethod(Method method, Class<?> cls, Object obj, Object... objArr) throws Throwable {
+        throw new UnsupportedOperationException();
+    }
+
+    boolean isDefaultMethod(Method method) {
+        return false;
+    }
+}

sources/retrofit2/RequestBuilder.java

@@ -0,0 +1,207 @@
+package retrofit2;
+
+import java.io.IOException;
+import okhttp3.FormBody;
+import okhttp3.Headers;
+import okhttp3.HttpUrl;
+import okhttp3.MediaType;
+import okhttp3.MultipartBody;
+import okhttp3.Request;
+import okhttp3.RequestBody;
+import okio.Buffer;
+import okio.BufferedSink;
+
+/* loaded from: classes2.dex */
+final class RequestBuilder {
+    private static final char[] HEX_DIGITS = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
+    private static final String PATH_SEGMENT_ALWAYS_ENCODE_SET = " \"<>^`{}|\\?#";
+    private final HttpUrl baseUrl;
+    private RequestBody body;
+    private MediaType contentType;
+    private FormBody.Builder formBuilder;
+    private final boolean hasBody;
+    private final String method;
+    private MultipartBody.Builder multipartBuilder;
+    private String relativeUrl;
+    private final Request.Builder requestBuilder = new Request.Builder();
+    private HttpUrl.Builder urlBuilder;
+
+    private static class ContentTypeOverridingRequestBody extends RequestBody {
+        private final MediaType contentType;
+        private final RequestBody delegate;
+
+        ContentTypeOverridingRequestBody(RequestBody requestBody, MediaType mediaType) {
+            this.delegate = requestBody;
+            this.contentType = mediaType;
+        }
+
+        @Override // okhttp3.RequestBody
+        public long contentLength() throws IOException {
+            return this.delegate.contentLength();
+        }
+
+        @Override // okhttp3.RequestBody
+        public MediaType contentType() {
+            return this.contentType;
+        }
+
+        @Override // okhttp3.RequestBody
+        public void writeTo(BufferedSink bufferedSink) throws IOException {
+            this.delegate.writeTo(bufferedSink);
+        }
+    }
+
+    RequestBuilder(String str, HttpUrl httpUrl, String str2, Headers headers, MediaType mediaType, boolean z, boolean z2, boolean z3) {
+        this.method = str;
+        this.baseUrl = httpUrl;
+        this.relativeUrl = str2;
+        this.contentType = mediaType;
+        this.hasBody = z;
+        if (headers != null) {
+            this.requestBuilder.headers(headers);
+        }
+        if (z2) {
+            this.formBuilder = new FormBody.Builder();
+        } else if (z3) {
+            this.multipartBuilder = new MultipartBody.Builder();
+            this.multipartBuilder.setType(MultipartBody.FORM);
+        }
+    }
+
+    private static String canonicalizeForPath(String str, boolean z) {
+        int length = str.length();
+        int i = 0;
+        while (i < length) {
+            int codePointAt = str.codePointAt(i);
+            if (codePointAt < 32 || codePointAt >= 127 || PATH_SEGMENT_ALWAYS_ENCODE_SET.indexOf(codePointAt) != -1 || (!z && (codePointAt == 47 || codePointAt == 37))) {
+                Buffer buffer = new Buffer();
+                buffer.writeUtf8(str, 0, i);
+                canonicalizeForPath(buffer, str, i, length, z);
+                return buffer.readUtf8();
+            }
+            i += Character.charCount(codePointAt);
+        }
+        return str;
+    }
+
+    void addFormField(String str, String str2, boolean z) {
+        if (z) {
+            this.formBuilder.addEncoded(str, str2);
+        } else {
+            this.formBuilder.add(str, str2);
+        }
+    }
+
+    void addHeader(String str, String str2) {
+        if (!"Content-Type".equalsIgnoreCase(str)) {
+            this.requestBuilder.addHeader(str, str2);
+            return;
+        }
+        MediaType parse = MediaType.parse(str2);
+        if (parse != null) {
+            this.contentType = parse;
+            return;
+        }
+        throw new IllegalArgumentException("Malformed content type: " + str2);
+    }
+
+    void addPart(Headers headers, RequestBody requestBody) {
+        this.multipartBuilder.addPart(headers, requestBody);
+    }
+
+    void addPathParam(String str, String str2, boolean z) {
+        String str3 = this.relativeUrl;
+        if (str3 == null) {
+            throw new AssertionError();
+        }
+        this.relativeUrl = str3.replace("{" + str + "}", canonicalizeForPath(str2, z));
+    }
+
+    void addQueryParam(String str, String str2, boolean z) {
+        String str3 = this.relativeUrl;
+        if (str3 != null) {
+            this.urlBuilder = this.baseUrl.newBuilder(str3);
+            if (this.urlBuilder == null) {
+                throw new IllegalArgumentException("Malformed URL. Base: " + this.baseUrl + ", Relative: " + this.relativeUrl);
+            }
+            this.relativeUrl = null;
+        }
+        if (z) {
+            this.urlBuilder.addEncodedQueryParameter(str, str2);
+        } else {
+            this.urlBuilder.addQueryParameter(str, str2);
+        }
+    }
+
+    Request build() {
+        HttpUrl resolve;
+        HttpUrl.Builder builder = this.urlBuilder;
+        if (builder != null) {
+            resolve = builder.build();
+        } else {
+            resolve = this.baseUrl.resolve(this.relativeUrl);
+            if (resolve == null) {
+                throw new IllegalArgumentException("Malformed URL. Base: " + this.baseUrl + ", Relative: " + this.relativeUrl);
+            }
+        }
+        RequestBody requestBody = this.body;
+        if (requestBody == null) {
+            FormBody.Builder builder2 = this.formBuilder;
+            if (builder2 != null) {
+                requestBody = builder2.build();
+            } else {
+                MultipartBody.Builder builder3 = this.multipartBuilder;
+                if (builder3 != null) {
+                    requestBody = builder3.build();
+                } else if (this.hasBody) {
+                    requestBody = RequestBody.create((MediaType) null, new byte[0]);
+                }
+            }
+        }
+        MediaType mediaType = this.contentType;
+        if (mediaType != null) {
+            if (requestBody != null) {
+                requestBody = new ContentTypeOverridingRequestBody(requestBody, mediaType);
+            } else {
+                this.requestBuilder.addHeader("Content-Type", mediaType.toString());
+            }
+        }
+        return this.requestBuilder.url(resolve).method(this.method, requestBody).build();
+    }
+
+    void setBody(RequestBody requestBody) {
+        this.body = requestBody;
+    }
+
+    void setRelativeUrl(Object obj) {
+        this.relativeUrl = obj.toString();
+    }
+
+    void addPart(MultipartBody.Part part) {
+        this.multipartBuilder.addPart(part);
+    }
+
+    private static void canonicalizeForPath(Buffer buffer, String str, int i, int i2, boolean z) {
+        Buffer buffer2 = null;
+        while (i < i2) {
+            int codePointAt = str.codePointAt(i);
+            if (!z || (codePointAt != 9 && codePointAt != 10 && codePointAt != 12 && codePointAt != 13)) {
+                if (codePointAt >= 32 && codePointAt < 127 && PATH_SEGMENT_ALWAYS_ENCODE_SET.indexOf(codePointAt) == -1 && (z || (codePointAt != 47 && codePointAt != 37))) {
+                    buffer.writeUtf8CodePoint(codePointAt);
+                } else {
+                    if (buffer2 == null) {
+                        buffer2 = new Buffer();
+                    }
+                    buffer2.writeUtf8CodePoint(codePointAt);
+                    while (!buffer2.exhausted()) {
+                        int readByte = buffer2.readByte() & 255;
+                        buffer.writeByte(37);
+                        buffer.writeByte((int) HEX_DIGITS[(readByte >> 4) & 15]);
+                        buffer.writeByte((int) HEX_DIGITS[readByte & 15]);
+                    }
+                }
+            }
+            i += Character.charCount(codePointAt);
+        }
+    }
+}

sources/retrofit2/Response.java

@@ -0,0 +1,85 @@
+package retrofit2;
+
+import okhttp3.Headers;
+import okhttp3.Protocol;
+import okhttp3.Request;
+import okhttp3.Response;
+import okhttp3.ResponseBody;
+
+/* loaded from: classes2.dex */
+public final class Response<T> {
+    private final T body;
+    private final ResponseBody errorBody;
+    private final okhttp3.Response rawResponse;
+
+    private Response(okhttp3.Response response, T t, ResponseBody responseBody) {
+        this.rawResponse = response;
+        this.body = t;
+        this.errorBody = responseBody;
+    }
+
+    public static <T> Response<T> error(int i, ResponseBody responseBody) {
+        if (i >= 400) {
+            return error(responseBody, new Response.Builder().code(i).message("Response.error()").protocol(Protocol.HTTP_1_1).request(new Request.Builder().url("http://localhost/").build()).build());
+        }
+        throw new IllegalArgumentException("code < 400: " + i);
+    }
+
+    public static <T> Response<T> success(T t) {
+        return success(t, new Response.Builder().code(200).message("OK").protocol(Protocol.HTTP_1_1).request(new Request.Builder().url("http://localhost/").build()).build());
+    }
+
+    public T body() {
+        return this.body;
+    }
+
+    public int code() {
+        return this.rawResponse.code();
+    }
+
+    public ResponseBody errorBody() {
+        return this.errorBody;
+    }
+
+    public Headers headers() {
+        return this.rawResponse.headers();
+    }
+
+    public boolean isSuccessful() {
+        return this.rawResponse.isSuccessful();
+    }
+
+    public String message() {
+        return this.rawResponse.message();
+    }
+
+    public okhttp3.Response raw() {
+        return this.rawResponse;
+    }
+
+    public String toString() {
+        return this.rawResponse.toString();
+    }
+
+    public static <T> Response<T> success(T t, Headers headers) {
+        Utils.checkNotNull(headers, "headers == null");
+        return success(t, new Response.Builder().code(200).message("OK").protocol(Protocol.HTTP_1_1).headers(headers).request(new Request.Builder().url("http://localhost/").build()).build());
+    }
+
+    public static <T> Response<T> error(ResponseBody responseBody, okhttp3.Response response) {
+        Utils.checkNotNull(responseBody, "body == null");
+        Utils.checkNotNull(response, "rawResponse == null");
+        if (!response.isSuccessful()) {
+            return new Response<>(response, null, responseBody);
+        }
+        throw new IllegalArgumentException("rawResponse should not be successful response");
+    }
+
+    public static <T> Response<T> success(T t, okhttp3.Response response) {
+        Utils.checkNotNull(response, "rawResponse == null");
+        if (response.isSuccessful()) {
+            return new Response<>(response, t, null);
+        }
+        throw new IllegalArgumentException("rawResponse must be successful response");
+    }
+}

sources/retrofit2/Retrofit.java

@@ -0,0 +1,348 @@
+package retrofit2;
+
+import java.lang.annotation.Annotation;
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.Method;
+import java.lang.reflect.Proxy;
+import java.lang.reflect.Type;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.Executor;
+import okhttp3.Call;
+import okhttp3.HttpUrl;
+import okhttp3.OkHttpClient;
+import okhttp3.RequestBody;
+import okhttp3.ResponseBody;
+import retrofit2.BuiltInConverters;
+import retrofit2.CallAdapter;
+import retrofit2.Converter;
+import retrofit2.ServiceMethod;
+
+/* loaded from: classes2.dex */
+public final class Retrofit {
+    final HttpUrl baseUrl;
+    final List<CallAdapter.Factory> callAdapterFactories;
+    final Call.Factory callFactory;
+    final Executor callbackExecutor;
+    final List<Converter.Factory> converterFactories;
+    private final Map<Method, ServiceMethod<?, ?>> serviceMethodCache = new ConcurrentHashMap();
+    final boolean validateEagerly;
+
+    Retrofit(Call.Factory factory, HttpUrl httpUrl, List<Converter.Factory> list, List<CallAdapter.Factory> list2, Executor executor, boolean z) {
+        this.callFactory = factory;
+        this.baseUrl = httpUrl;
+        this.converterFactories = list;
+        this.callAdapterFactories = list2;
+        this.callbackExecutor = executor;
+        this.validateEagerly = z;
+    }
+
+    private void eagerlyValidateMethods(Class<?> cls) {
+        Platform platform = Platform.get();
+        for (Method method : cls.getDeclaredMethods()) {
+            if (!platform.isDefaultMethod(method)) {
+                loadServiceMethod(method);
+            }
+        }
+    }
+
+    public HttpUrl baseUrl() {
+        return this.baseUrl;
+    }
+
+    public CallAdapter<?, ?> callAdapter(Type type, Annotation[] annotationArr) {
+        return nextCallAdapter(null, type, annotationArr);
+    }
+
+    public List<CallAdapter.Factory> callAdapterFactories() {
+        return this.callAdapterFactories;
+    }
+
+    public Call.Factory callFactory() {
+        return this.callFactory;
+    }
+
+    public Executor callbackExecutor() {
+        return this.callbackExecutor;
+    }
+
+    public List<Converter.Factory> converterFactories() {
+        return this.converterFactories;
+    }
+
+    public <T> T create(final Class<T> cls) {
+        Utils.validateServiceInterface(cls);
+        if (this.validateEagerly) {
+            eagerlyValidateMethods(cls);
+        }
+        return (T) Proxy.newProxyInstance(cls.getClassLoader(), new Class[]{cls}, new InvocationHandler() { // from class: retrofit2.Retrofit.1
+            private final Platform platform = Platform.get();
+
+            @Override // java.lang.reflect.InvocationHandler
+            public Object invoke(Object obj, Method method, Object[] objArr) throws Throwable {
+                if (method.getDeclaringClass() == Object.class) {
+                    return method.invoke(this, objArr);
+                }
+                if (this.platform.isDefaultMethod(method)) {
+                    return this.platform.invokeDefaultMethod(method, cls, obj, objArr);
+                }
+                ServiceMethod<?, ?> loadServiceMethod = Retrofit.this.loadServiceMethod(method);
+                return loadServiceMethod.adapt(new OkHttpCall(loadServiceMethod, objArr));
+            }
+        });
+    }
+
+    ServiceMethod<?, ?> loadServiceMethod(Method method) {
+        ServiceMethod serviceMethod;
+        ServiceMethod<?, ?> serviceMethod2 = this.serviceMethodCache.get(method);
+        if (serviceMethod2 != null) {
+            return serviceMethod2;
+        }
+        synchronized (this.serviceMethodCache) {
+            serviceMethod = this.serviceMethodCache.get(method);
+            if (serviceMethod == null) {
+                serviceMethod = new ServiceMethod.Builder(this, method).build();
+                this.serviceMethodCache.put(method, serviceMethod);
+            }
+        }
+        return serviceMethod;
+    }
+
+    public Builder newBuilder() {
+        return new Builder(this);
+    }
+
+    public CallAdapter<?, ?> nextCallAdapter(CallAdapter.Factory factory, Type type, Annotation[] annotationArr) {
+        Utils.checkNotNull(type, "returnType == null");
+        Utils.checkNotNull(annotationArr, "annotations == null");
+        int indexOf = this.callAdapterFactories.indexOf(factory) + 1;
+        int size = this.callAdapterFactories.size();
+        for (int i = indexOf; i < size; i++) {
+            CallAdapter<?, ?> callAdapter = this.callAdapterFactories.get(i).get(type, annotationArr, this);
+            if (callAdapter != null) {
+                return callAdapter;
+            }
+        }
+        StringBuilder sb = new StringBuilder("Could not locate call adapter for ");
+        sb.append(type);
+        sb.append(".\n");
+        if (factory != null) {
+            sb.append("  Skipped:");
+            for (int i2 = 0; i2 < indexOf; i2++) {
+                sb.append("\n   * ");
+                sb.append(this.callAdapterFactories.get(i2).getClass().getName());
+            }
+            sb.append('\n');
+        }
+        sb.append("  Tried:");
+        int size2 = this.callAdapterFactories.size();
+        while (indexOf < size2) {
+            sb.append("\n   * ");
+            sb.append(this.callAdapterFactories.get(indexOf).getClass().getName());
+            indexOf++;
+        }
+        throw new IllegalArgumentException(sb.toString());
+    }
+
+    public <T> Converter<T, RequestBody> nextRequestBodyConverter(Converter.Factory factory, Type type, Annotation[] annotationArr, Annotation[] annotationArr2) {
+        Utils.checkNotNull(type, "type == null");
+        Utils.checkNotNull(annotationArr, "parameterAnnotations == null");
+        Utils.checkNotNull(annotationArr2, "methodAnnotations == null");
+        int indexOf = this.converterFactories.indexOf(factory) + 1;
+        int size = this.converterFactories.size();
+        for (int i = indexOf; i < size; i++) {
+            Converter<T, RequestBody> converter = (Converter<T, RequestBody>) this.converterFactories.get(i).requestBodyConverter(type, annotationArr, annotationArr2, this);
+            if (converter != null) {
+                return converter;
+            }
+        }
+        StringBuilder sb = new StringBuilder("Could not locate RequestBody converter for ");
+        sb.append(type);
+        sb.append(".\n");
+        if (factory != null) {
+            sb.append("  Skipped:");
+            for (int i2 = 0; i2 < indexOf; i2++) {
+                sb.append("\n   * ");
+                sb.append(this.converterFactories.get(i2).getClass().getName());
+            }
+            sb.append('\n');
+        }
+        sb.append("  Tried:");
+        int size2 = this.converterFactories.size();
+        while (indexOf < size2) {
+            sb.append("\n   * ");
+            sb.append(this.converterFactories.get(indexOf).getClass().getName());
+            indexOf++;
+        }
+        throw new IllegalArgumentException(sb.toString());
+    }
+
+    public <T> Converter<ResponseBody, T> nextResponseBodyConverter(Converter.Factory factory, Type type, Annotation[] annotationArr) {
+        Utils.checkNotNull(type, "type == null");
+        Utils.checkNotNull(annotationArr, "annotations == null");
+        int indexOf = this.converterFactories.indexOf(factory) + 1;
+        int size = this.converterFactories.size();
+        for (int i = indexOf; i < size; i++) {
+            Converter<ResponseBody, T> converter = (Converter<ResponseBody, T>) this.converterFactories.get(i).responseBodyConverter(type, annotationArr, this);
+            if (converter != null) {
+                return converter;
+            }
+        }
+        StringBuilder sb = new StringBuilder("Could not locate ResponseBody converter for ");
+        sb.append(type);
+        sb.append(".\n");
+        if (factory != null) {
+            sb.append("  Skipped:");
+            for (int i2 = 0; i2 < indexOf; i2++) {
+                sb.append("\n   * ");
+                sb.append(this.converterFactories.get(i2).getClass().getName());
+            }
+            sb.append('\n');
+        }
+        sb.append("  Tried:");
+        int size2 = this.converterFactories.size();
+        while (indexOf < size2) {
+            sb.append("\n   * ");
+            sb.append(this.converterFactories.get(indexOf).getClass().getName());
+            indexOf++;
+        }
+        throw new IllegalArgumentException(sb.toString());
+    }
+
+    public <T> Converter<T, RequestBody> requestBodyConverter(Type type, Annotation[] annotationArr, Annotation[] annotationArr2) {
+        return nextRequestBodyConverter(null, type, annotationArr, annotationArr2);
+    }
+
+    public <T> Converter<ResponseBody, T> responseBodyConverter(Type type, Annotation[] annotationArr) {
+        return nextResponseBodyConverter(null, type, annotationArr);
+    }
+
+    public <T> Converter<T, String> stringConverter(Type type, Annotation[] annotationArr) {
+        Utils.checkNotNull(type, "type == null");
+        Utils.checkNotNull(annotationArr, "annotations == null");
+        int size = this.converterFactories.size();
+        for (int i = 0; i < size; i++) {
+            Converter<T, String> converter = (Converter<T, String>) this.converterFactories.get(i).stringConverter(type, annotationArr, this);
+            if (converter != null) {
+                return converter;
+            }
+        }
+        return BuiltInConverters.ToStringConverter.INSTANCE;
+    }
+
+    public static final class Builder {
+        private HttpUrl baseUrl;
+        private final List<CallAdapter.Factory> callAdapterFactories;
+        private Call.Factory callFactory;
+        private Executor callbackExecutor;
+        private final List<Converter.Factory> converterFactories;
+        private final Platform platform;
+        private boolean validateEagerly;
+
+        Builder(Platform platform) {
+            this.converterFactories = new ArrayList();
+            this.callAdapterFactories = new ArrayList();
+            this.platform = platform;
+        }
+
+        /* JADX WARN: Multi-variable type inference failed */
+        public Builder addCallAdapterFactory(CallAdapter.Factory factory) {
+            this.callAdapterFactories.add(Utils.checkNotNull(factory, "factory == null"));
+            return this;
+        }
+
+        /* JADX WARN: Multi-variable type inference failed */
+        public Builder addConverterFactory(Converter.Factory factory) {
+            this.converterFactories.add(Utils.checkNotNull(factory, "factory == null"));
+            return this;
+        }
+
+        public Builder baseUrl(String str) {
+            Utils.checkNotNull(str, "baseUrl == null");
+            HttpUrl parse = HttpUrl.parse(str);
+            if (parse != null) {
+                return baseUrl(parse);
+            }
+            throw new IllegalArgumentException("Illegal URL: " + str);
+        }
+
+        public Retrofit build() {
+            if (this.baseUrl == null) {
+                throw new IllegalStateException("Base URL required.");
+            }
+            Call.Factory factory = this.callFactory;
+            if (factory == null) {
+                factory = new OkHttpClient();
+            }
+            Call.Factory factory2 = factory;
+            Executor executor = this.callbackExecutor;
+            if (executor == null) {
+                executor = this.platform.defaultCallbackExecutor();
+            }
+            Executor executor2 = executor;
+            ArrayList arrayList = new ArrayList(this.callAdapterFactories);
+            arrayList.add(this.platform.defaultCallAdapterFactory(executor2));
+            ArrayList arrayList2 = new ArrayList(this.converterFactories.size() + 1);
+            arrayList2.add(new BuiltInConverters());
+            arrayList2.addAll(this.converterFactories);
+            return new Retrofit(factory2, this.baseUrl, Collections.unmodifiableList(arrayList2), Collections.unmodifiableList(arrayList), executor2, this.validateEagerly);
+        }
+
+        public List<CallAdapter.Factory> callAdapterFactories() {
+            return this.callAdapterFactories;
+        }
+
+        public Builder callFactory(Call.Factory factory) {
+            this.callFactory = (Call.Factory) Utils.checkNotNull(factory, "factory == null");
+            return this;
+        }
+
+        public Builder callbackExecutor(Executor executor) {
+            this.callbackExecutor = (Executor) Utils.checkNotNull(executor, "executor == null");
+            return this;
+        }
+
+        public Builder client(OkHttpClient okHttpClient) {
+            return callFactory((Call.Factory) Utils.checkNotNull(okHttpClient, "client == null"));
+        }
+
+        public List<Converter.Factory> converterFactories() {
+            return this.converterFactories;
+        }
+
+        public Builder validateEagerly(boolean z) {
+            this.validateEagerly = z;
+            return this;
+        }
+
+        public Builder() {
+            this(Platform.get());
+        }
+
+        public Builder baseUrl(HttpUrl httpUrl) {
+            Utils.checkNotNull(httpUrl, "baseUrl == null");
+            if ("".equals(httpUrl.pathSegments().get(r0.size() - 1))) {
+                this.baseUrl = httpUrl;
+                return this;
+            }
+            throw new IllegalArgumentException("baseUrl must end in /: " + httpUrl);
+        }
+
+        Builder(Retrofit retrofit) {
+            this.converterFactories = new ArrayList();
+            this.callAdapterFactories = new ArrayList();
+            this.platform = Platform.get();
+            this.callFactory = retrofit.callFactory;
+            this.baseUrl = retrofit.baseUrl;
+            this.converterFactories.addAll(retrofit.converterFactories);
+            this.converterFactories.remove(0);
+            this.callAdapterFactories.addAll(retrofit.callAdapterFactories);
+            this.callAdapterFactories.remove(r0.size() - 1);
+            this.callbackExecutor = retrofit.callbackExecutor;
+            this.validateEagerly = retrofit.validateEagerly;
+        }
+    }
+}

sources/retrofit2/ServiceMethod.java

@@ -0,0 +1,598 @@
+package retrofit2;
+
+import java.io.IOException;
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Method;
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Type;
+import java.net.URI;
+import java.util.LinkedHashSet;
+import java.util.Map;
+import java.util.Set;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import okhttp3.Call;
+import okhttp3.Headers;
+import okhttp3.HttpUrl;
+import okhttp3.MediaType;
+import okhttp3.MultipartBody;
+import okhttp3.RequestBody;
+import okhttp3.ResponseBody;
+import retrofit2.ParameterHandler;
+import retrofit2.http.Body;
+import retrofit2.http.DELETE;
+import retrofit2.http.Field;
+import retrofit2.http.FieldMap;
+import retrofit2.http.FormUrlEncoded;
+import retrofit2.http.GET;
+import retrofit2.http.HEAD;
+import retrofit2.http.HTTP;
+import retrofit2.http.Header;
+import retrofit2.http.HeaderMap;
+import retrofit2.http.Multipart;
+import retrofit2.http.OPTIONS;
+import retrofit2.http.PATCH;
+import retrofit2.http.POST;
+import retrofit2.http.PUT;
+import retrofit2.http.Part;
+import retrofit2.http.PartMap;
+import retrofit2.http.Path;
+import retrofit2.http.Query;
+import retrofit2.http.QueryMap;
+import retrofit2.http.QueryName;
+import retrofit2.http.Url;
+
+/* loaded from: classes2.dex */
+final class ServiceMethod<R, T> {
+    private final HttpUrl baseUrl;
+    private final CallAdapter<R, T> callAdapter;
+    private final Call.Factory callFactory;
+    private final MediaType contentType;
+    private final boolean hasBody;
+    private final Headers headers;
+    private final String httpMethod;
+    private final boolean isFormEncoded;
+    private final boolean isMultipart;
+    private final ParameterHandler<?>[] parameterHandlers;
+    private final String relativeUrl;
+    private final Converter<ResponseBody, R> responseConverter;
+    static final Pattern PARAM_URL_REGEX = Pattern.compile("\\{([a-zA-Z][a-zA-Z0-9_-]*)\\}");
+    static final String PARAM = "[a-zA-Z][a-zA-Z0-9_-]*";
+    static final Pattern PARAM_NAME_REGEX = Pattern.compile(PARAM);
+
+    static final class Builder<T, R> {
+        CallAdapter<T, R> callAdapter;
+        MediaType contentType;
+        boolean gotBody;
+        boolean gotField;
+        boolean gotPart;
+        boolean gotPath;
+        boolean gotQuery;
+        boolean gotUrl;
+        boolean hasBody;
+        Headers headers;
+        String httpMethod;
+        boolean isFormEncoded;
+        boolean isMultipart;
+        final Method method;
+        final Annotation[] methodAnnotations;
+        final Annotation[][] parameterAnnotationsArray;
+        ParameterHandler<?>[] parameterHandlers;
+        final Type[] parameterTypes;
+        String relativeUrl;
+        Set<String> relativeUrlParamNames;
+        Converter<ResponseBody, T> responseConverter;
+        Type responseType;
+        final Retrofit retrofit;
+
+        Builder(Retrofit retrofit, Method method) {
+            this.retrofit = retrofit;
+            this.method = method;
+            this.methodAnnotations = method.getAnnotations();
+            this.parameterTypes = method.getGenericParameterTypes();
+            this.parameterAnnotationsArray = method.getParameterAnnotations();
+        }
+
+        private CallAdapter<T, R> createCallAdapter() {
+            Type genericReturnType = this.method.getGenericReturnType();
+            if (Utils.hasUnresolvableType(genericReturnType)) {
+                throw methodError("Method return type must not include a type variable or wildcard: %s", genericReturnType);
+            }
+            if (genericReturnType == Void.TYPE) {
+                throw methodError("Service methods cannot return void.", new Object[0]);
+            }
+            try {
+                return (CallAdapter<T, R>) this.retrofit.callAdapter(genericReturnType, this.method.getAnnotations());
+            } catch (RuntimeException e) {
+                throw methodError(e, "Unable to create call adapter for %s", genericReturnType);
+            }
+        }
+
+        private Converter<ResponseBody, T> createResponseConverter() {
+            try {
+                return this.retrofit.responseBodyConverter(this.responseType, this.method.getAnnotations());
+            } catch (RuntimeException e) {
+                throw methodError(e, "Unable to create converter for %s", this.responseType);
+            }
+        }
+
+        private RuntimeException methodError(String str, Object... objArr) {
+            return methodError(null, str, objArr);
+        }
+
+        private RuntimeException parameterError(Throwable th, int i, String str, Object... objArr) {
+            return methodError(th, str + " (parameter #" + (i + 1) + ")", objArr);
+        }
+
+        private Headers parseHeaders(String[] strArr) {
+            Headers.Builder builder = new Headers.Builder();
+            for (String str : strArr) {
+                int indexOf = str.indexOf(58);
+                if (indexOf == -1 || indexOf == 0 || indexOf == str.length() - 1) {
+                    throw methodError("@Headers value must be in the form \"Name: Value\". Found: \"%s\"", str);
+                }
+                String substring = str.substring(0, indexOf);
+                String trim = str.substring(indexOf + 1).trim();
+                if ("Content-Type".equalsIgnoreCase(substring)) {
+                    MediaType parse = MediaType.parse(trim);
+                    if (parse == null) {
+                        throw methodError("Malformed content type: %s", trim);
+                    }
+                    this.contentType = parse;
+                } else {
+                    builder.add(substring, trim);
+                }
+            }
+            return builder.build();
+        }
+
+        private void parseHttpMethodAndPath(String str, String str2, boolean z) {
+            String str3 = this.httpMethod;
+            if (str3 != null) {
+                throw methodError("Only one HTTP method is allowed. Found: %s and %s.", str3, str);
+            }
+            this.httpMethod = str;
+            this.hasBody = z;
+            if (str2.isEmpty()) {
+                return;
+            }
+            int indexOf = str2.indexOf(63);
+            if (indexOf != -1 && indexOf < str2.length() - 1) {
+                String substring = str2.substring(indexOf + 1);
+                if (ServiceMethod.PARAM_URL_REGEX.matcher(substring).find()) {
+                    throw methodError("URL query string \"%s\" must not have replace block. For dynamic query parameters use @Query.", substring);
+                }
+            }
+            this.relativeUrl = str2;
+            this.relativeUrlParamNames = ServiceMethod.parsePathParameters(str2);
+        }
+
+        private void parseMethodAnnotation(Annotation annotation) {
+            if (annotation instanceof DELETE) {
+                parseHttpMethodAndPath("DELETE", ((DELETE) annotation).value(), false);
+                return;
+            }
+            if (annotation instanceof GET) {
+                parseHttpMethodAndPath("GET", ((GET) annotation).value(), false);
+                return;
+            }
+            if (annotation instanceof HEAD) {
+                parseHttpMethodAndPath("HEAD", ((HEAD) annotation).value(), false);
+                if (!Void.class.equals(this.responseType)) {
+                    throw methodError("HEAD method must use Void as response type.", new Object[0]);
+                }
+                return;
+            }
+            if (annotation instanceof PATCH) {
+                parseHttpMethodAndPath("PATCH", ((PATCH) annotation).value(), true);
+                return;
+            }
+            if (annotation instanceof POST) {
+                parseHttpMethodAndPath("POST", ((POST) annotation).value(), true);
+                return;
+            }
+            if (annotation instanceof PUT) {
+                parseHttpMethodAndPath("PUT", ((PUT) annotation).value(), true);
+                return;
+            }
+            if (annotation instanceof OPTIONS) {
+                parseHttpMethodAndPath("OPTIONS", ((OPTIONS) annotation).value(), false);
+                return;
+            }
+            if (annotation instanceof HTTP) {
+                HTTP http = (HTTP) annotation;
+                parseHttpMethodAndPath(http.method(), http.path(), http.hasBody());
+                return;
+            }
+            if (annotation instanceof retrofit2.http.Headers) {
+                String[] value = ((retrofit2.http.Headers) annotation).value();
+                if (value.length == 0) {
+                    throw methodError("@Headers annotation is empty.", new Object[0]);
+                }
+                this.headers = parseHeaders(value);
+                return;
+            }
+            if (annotation instanceof Multipart) {
+                if (this.isFormEncoded) {
+                    throw methodError("Only one encoding annotation is allowed.", new Object[0]);
+                }
+                this.isMultipart = true;
+            } else if (annotation instanceof FormUrlEncoded) {
+                if (this.isMultipart) {
+                    throw methodError("Only one encoding annotation is allowed.", new Object[0]);
+                }
+                this.isFormEncoded = true;
+            }
+        }
+
+        private ParameterHandler<?> parseParameter(int i, Type type, Annotation[] annotationArr) {
+            ParameterHandler<?> parameterHandler = null;
+            for (Annotation annotation : annotationArr) {
+                ParameterHandler<?> parseParameterAnnotation = parseParameterAnnotation(i, type, annotationArr, annotation);
+                if (parseParameterAnnotation != null) {
+                    if (parameterHandler != null) {
+                        throw parameterError(i, "Multiple Retrofit annotations found, only one allowed.", new Object[0]);
+                    }
+                    parameterHandler = parseParameterAnnotation;
+                }
+            }
+            if (parameterHandler != null) {
+                return parameterHandler;
+            }
+            throw parameterError(i, "No Retrofit annotation found.", new Object[0]);
+        }
+
+        private ParameterHandler<?> parseParameterAnnotation(int i, Type type, Annotation[] annotationArr, Annotation annotation) {
+            if (annotation instanceof Url) {
+                if (this.gotUrl) {
+                    throw parameterError(i, "Multiple @Url method annotations found.", new Object[0]);
+                }
+                if (this.gotPath) {
+                    throw parameterError(i, "@Path parameters may not be used with @Url.", new Object[0]);
+                }
+                if (this.gotQuery) {
+                    throw parameterError(i, "A @Url parameter must not come after a @Query", new Object[0]);
+                }
+                if (this.relativeUrl != null) {
+                    throw parameterError(i, "@Url cannot be used with @%s URL", this.httpMethod);
+                }
+                this.gotUrl = true;
+                if (type == HttpUrl.class || type == String.class || type == URI.class || ((type instanceof Class) && "android.net.Uri".equals(((Class) type).getName()))) {
+                    return new ParameterHandler.RelativeUrl();
+                }
+                throw parameterError(i, "@Url must be okhttp3.HttpUrl, String, java.net.URI, or android.net.Uri type.", new Object[0]);
+            }
+            if (annotation instanceof Path) {
+                if (this.gotQuery) {
+                    throw parameterError(i, "A @Path parameter must not come after a @Query.", new Object[0]);
+                }
+                if (this.gotUrl) {
+                    throw parameterError(i, "@Path parameters may not be used with @Url.", new Object[0]);
+                }
+                if (this.relativeUrl == null) {
+                    throw parameterError(i, "@Path can only be used with relative url on @%s", this.httpMethod);
+                }
+                this.gotPath = true;
+                Path path = (Path) annotation;
+                String value = path.value();
+                validatePathName(i, value);
+                return new ParameterHandler.Path(value, this.retrofit.stringConverter(type, annotationArr), path.encoded());
+            }
+            if (annotation instanceof Query) {
+                Query query = (Query) annotation;
+                String value2 = query.value();
+                boolean encoded = query.encoded();
+                Class<?> rawType = Utils.getRawType(type);
+                this.gotQuery = true;
+                if (!Iterable.class.isAssignableFrom(rawType)) {
+                    return rawType.isArray() ? new ParameterHandler.Query(value2, this.retrofit.stringConverter(ServiceMethod.boxIfPrimitive(rawType.getComponentType()), annotationArr), encoded).array() : new ParameterHandler.Query(value2, this.retrofit.stringConverter(type, annotationArr), encoded);
+                }
+                if (type instanceof ParameterizedType) {
+                    return new ParameterHandler.Query(value2, this.retrofit.stringConverter(Utils.getParameterUpperBound(0, (ParameterizedType) type), annotationArr), encoded).iterable();
+                }
+                throw parameterError(i, rawType.getSimpleName() + " must include generic type (e.g., " + rawType.getSimpleName() + "<String>)", new Object[0]);
+            }
+            if (annotation instanceof QueryName) {
+                boolean encoded2 = ((QueryName) annotation).encoded();
+                Class<?> rawType2 = Utils.getRawType(type);
+                this.gotQuery = true;
+                if (!Iterable.class.isAssignableFrom(rawType2)) {
+                    return rawType2.isArray() ? new ParameterHandler.QueryName(this.retrofit.stringConverter(ServiceMethod.boxIfPrimitive(rawType2.getComponentType()), annotationArr), encoded2).array() : new ParameterHandler.QueryName(this.retrofit.stringConverter(type, annotationArr), encoded2);
+                }
+                if (type instanceof ParameterizedType) {
+                    return new ParameterHandler.QueryName(this.retrofit.stringConverter(Utils.getParameterUpperBound(0, (ParameterizedType) type), annotationArr), encoded2).iterable();
+                }
+                throw parameterError(i, rawType2.getSimpleName() + " must include generic type (e.g., " + rawType2.getSimpleName() + "<String>)", new Object[0]);
+            }
+            if (annotation instanceof QueryMap) {
+                Class<?> rawType3 = Utils.getRawType(type);
+                if (!Map.class.isAssignableFrom(rawType3)) {
+                    throw parameterError(i, "@QueryMap parameter type must be Map.", new Object[0]);
+                }
+                Type supertype = Utils.getSupertype(type, rawType3, Map.class);
+                if (!(supertype instanceof ParameterizedType)) {
+                    throw parameterError(i, "Map must include generic types (e.g., Map<String, String>)", new Object[0]);
+                }
+                ParameterizedType parameterizedType = (ParameterizedType) supertype;
+                Type parameterUpperBound = Utils.getParameterUpperBound(0, parameterizedType);
+                if (String.class == parameterUpperBound) {
+                    return new ParameterHandler.QueryMap(this.retrofit.stringConverter(Utils.getParameterUpperBound(1, parameterizedType), annotationArr), ((QueryMap) annotation).encoded());
+                }
+                throw parameterError(i, "@QueryMap keys must be of type String: " + parameterUpperBound, new Object[0]);
+            }
+            if (annotation instanceof Header) {
+                String value3 = ((Header) annotation).value();
+                Class<?> rawType4 = Utils.getRawType(type);
+                if (!Iterable.class.isAssignableFrom(rawType4)) {
+                    return rawType4.isArray() ? new ParameterHandler.Header(value3, this.retrofit.stringConverter(ServiceMethod.boxIfPrimitive(rawType4.getComponentType()), annotationArr)).array() : new ParameterHandler.Header(value3, this.retrofit.stringConverter(type, annotationArr));
+                }
+                if (type instanceof ParameterizedType) {
+                    return new ParameterHandler.Header(value3, this.retrofit.stringConverter(Utils.getParameterUpperBound(0, (ParameterizedType) type), annotationArr)).iterable();
+                }
+                throw parameterError(i, rawType4.getSimpleName() + " must include generic type (e.g., " + rawType4.getSimpleName() + "<String>)", new Object[0]);
+            }
+            if (annotation instanceof HeaderMap) {
+                Class<?> rawType5 = Utils.getRawType(type);
+                if (!Map.class.isAssignableFrom(rawType5)) {
+                    throw parameterError(i, "@HeaderMap parameter type must be Map.", new Object[0]);
+                }
+                Type supertype2 = Utils.getSupertype(type, rawType5, Map.class);
+                if (!(supertype2 instanceof ParameterizedType)) {
+                    throw parameterError(i, "Map must include generic types (e.g., Map<String, String>)", new Object[0]);
+                }
+                ParameterizedType parameterizedType2 = (ParameterizedType) supertype2;
+                Type parameterUpperBound2 = Utils.getParameterUpperBound(0, parameterizedType2);
+                if (String.class == parameterUpperBound2) {
+                    return new ParameterHandler.HeaderMap(this.retrofit.stringConverter(Utils.getParameterUpperBound(1, parameterizedType2), annotationArr));
+                }
+                throw parameterError(i, "@HeaderMap keys must be of type String: " + parameterUpperBound2, new Object[0]);
+            }
+            if (annotation instanceof Field) {
+                if (!this.isFormEncoded) {
+                    throw parameterError(i, "@Field parameters can only be used with form encoding.", new Object[0]);
+                }
+                Field field = (Field) annotation;
+                String value4 = field.value();
+                boolean encoded3 = field.encoded();
+                this.gotField = true;
+                Class<?> rawType6 = Utils.getRawType(type);
+                if (!Iterable.class.isAssignableFrom(rawType6)) {
+                    return rawType6.isArray() ? new ParameterHandler.Field(value4, this.retrofit.stringConverter(ServiceMethod.boxIfPrimitive(rawType6.getComponentType()), annotationArr), encoded3).array() : new ParameterHandler.Field(value4, this.retrofit.stringConverter(type, annotationArr), encoded3);
+                }
+                if (type instanceof ParameterizedType) {
+                    return new ParameterHandler.Field(value4, this.retrofit.stringConverter(Utils.getParameterUpperBound(0, (ParameterizedType) type), annotationArr), encoded3).iterable();
+                }
+                throw parameterError(i, rawType6.getSimpleName() + " must include generic type (e.g., " + rawType6.getSimpleName() + "<String>)", new Object[0]);
+            }
+            if (annotation instanceof FieldMap) {
+                if (!this.isFormEncoded) {
+                    throw parameterError(i, "@FieldMap parameters can only be used with form encoding.", new Object[0]);
+                }
+                Class<?> rawType7 = Utils.getRawType(type);
+                if (!Map.class.isAssignableFrom(rawType7)) {
+                    throw parameterError(i, "@FieldMap parameter type must be Map.", new Object[0]);
+                }
+                Type supertype3 = Utils.getSupertype(type, rawType7, Map.class);
+                if (!(supertype3 instanceof ParameterizedType)) {
+                    throw parameterError(i, "Map must include generic types (e.g., Map<String, String>)", new Object[0]);
+                }
+                ParameterizedType parameterizedType3 = (ParameterizedType) supertype3;
+                Type parameterUpperBound3 = Utils.getParameterUpperBound(0, parameterizedType3);
+                if (String.class == parameterUpperBound3) {
+                    Converter<T, String> stringConverter = this.retrofit.stringConverter(Utils.getParameterUpperBound(1, parameterizedType3), annotationArr);
+                    this.gotField = true;
+                    return new ParameterHandler.FieldMap(stringConverter, ((FieldMap) annotation).encoded());
+                }
+                throw parameterError(i, "@FieldMap keys must be of type String: " + parameterUpperBound3, new Object[0]);
+            }
+            if (!(annotation instanceof Part)) {
+                if (!(annotation instanceof PartMap)) {
+                    if (!(annotation instanceof Body)) {
+                        return null;
+                    }
+                    if (this.isFormEncoded || this.isMultipart) {
+                        throw parameterError(i, "@Body parameters cannot be used with form or multi-part encoding.", new Object[0]);
+                    }
+                    if (this.gotBody) {
+                        throw parameterError(i, "Multiple @Body method annotations found.", new Object[0]);
+                    }
+                    try {
+                        Converter<T, RequestBody> requestBodyConverter = this.retrofit.requestBodyConverter(type, annotationArr, this.methodAnnotations);
+                        this.gotBody = true;
+                        return new ParameterHandler.Body(requestBodyConverter);
+                    } catch (RuntimeException e) {
+                        throw parameterError(e, i, "Unable to create @Body converter for %s", type);
+                    }
+                }
+                if (!this.isMultipart) {
+                    throw parameterError(i, "@PartMap parameters can only be used with multipart encoding.", new Object[0]);
+                }
+                this.gotPart = true;
+                Class<?> rawType8 = Utils.getRawType(type);
+                if (!Map.class.isAssignableFrom(rawType8)) {
+                    throw parameterError(i, "@PartMap parameter type must be Map.", new Object[0]);
+                }
+                Type supertype4 = Utils.getSupertype(type, rawType8, Map.class);
+                if (!(supertype4 instanceof ParameterizedType)) {
+                    throw parameterError(i, "Map must include generic types (e.g., Map<String, String>)", new Object[0]);
+                }
+                ParameterizedType parameterizedType4 = (ParameterizedType) supertype4;
+                Type parameterUpperBound4 = Utils.getParameterUpperBound(0, parameterizedType4);
+                if (String.class == parameterUpperBound4) {
+                    Type parameterUpperBound5 = Utils.getParameterUpperBound(1, parameterizedType4);
+                    if (MultipartBody.Part.class.isAssignableFrom(Utils.getRawType(parameterUpperBound5))) {
+                        throw parameterError(i, "@PartMap values cannot be MultipartBody.Part. Use @Part List<Part> or a different value type instead.", new Object[0]);
+                    }
+                    return new ParameterHandler.PartMap(this.retrofit.requestBodyConverter(parameterUpperBound5, annotationArr, this.methodAnnotations), ((PartMap) annotation).encoding());
+                }
+                throw parameterError(i, "@PartMap keys must be of type String: " + parameterUpperBound4, new Object[0]);
+            }
+            if (!this.isMultipart) {
+                throw parameterError(i, "@Part parameters can only be used with multipart encoding.", new Object[0]);
+            }
+            Part part = (Part) annotation;
+            this.gotPart = true;
+            String value5 = part.value();
+            Class<?> rawType9 = Utils.getRawType(type);
+            if (value5.isEmpty()) {
+                if (!Iterable.class.isAssignableFrom(rawType9)) {
+                    if (rawType9.isArray()) {
+                        if (MultipartBody.Part.class.isAssignableFrom(rawType9.getComponentType())) {
+                            return ParameterHandler.RawPart.INSTANCE.array();
+                        }
+                        throw parameterError(i, "@Part annotation must supply a name or use MultipartBody.Part parameter type.", new Object[0]);
+                    }
+                    if (MultipartBody.Part.class.isAssignableFrom(rawType9)) {
+                        return ParameterHandler.RawPart.INSTANCE;
+                    }
+                    throw parameterError(i, "@Part annotation must supply a name or use MultipartBody.Part parameter type.", new Object[0]);
+                }
+                if (type instanceof ParameterizedType) {
+                    if (MultipartBody.Part.class.isAssignableFrom(Utils.getRawType(Utils.getParameterUpperBound(0, (ParameterizedType) type)))) {
+                        return ParameterHandler.RawPart.INSTANCE.iterable();
+                    }
+                    throw parameterError(i, "@Part annotation must supply a name or use MultipartBody.Part parameter type.", new Object[0]);
+                }
+                throw parameterError(i, rawType9.getSimpleName() + " must include generic type (e.g., " + rawType9.getSimpleName() + "<String>)", new Object[0]);
+            }
+            Headers of = Headers.of("Content-Disposition", "form-data; name=\"" + value5 + "\"", "Content-Transfer-Encoding", part.encoding());
+            if (!Iterable.class.isAssignableFrom(rawType9)) {
+                if (!rawType9.isArray()) {
+                    if (MultipartBody.Part.class.isAssignableFrom(rawType9)) {
+                        throw parameterError(i, "@Part parameters using the MultipartBody.Part must not include a part name in the annotation.", new Object[0]);
+                    }
+                    return new ParameterHandler.Part(of, this.retrofit.requestBodyConverter(type, annotationArr, this.methodAnnotations));
+                }
+                Class<?> boxIfPrimitive = ServiceMethod.boxIfPrimitive(rawType9.getComponentType());
+                if (MultipartBody.Part.class.isAssignableFrom(boxIfPrimitive)) {
+                    throw parameterError(i, "@Part parameters using the MultipartBody.Part must not include a part name in the annotation.", new Object[0]);
+                }
+                return new ParameterHandler.Part(of, this.retrofit.requestBodyConverter(boxIfPrimitive, annotationArr, this.methodAnnotations)).array();
+            }
+            if (type instanceof ParameterizedType) {
+                Type parameterUpperBound6 = Utils.getParameterUpperBound(0, (ParameterizedType) type);
+                if (MultipartBody.Part.class.isAssignableFrom(Utils.getRawType(parameterUpperBound6))) {
+                    throw parameterError(i, "@Part parameters using the MultipartBody.Part must not include a part name in the annotation.", new Object[0]);
+                }
+                return new ParameterHandler.Part(of, this.retrofit.requestBodyConverter(parameterUpperBound6, annotationArr, this.methodAnnotations)).iterable();
+            }
+            throw parameterError(i, rawType9.getSimpleName() + " must include generic type (e.g., " + rawType9.getSimpleName() + "<String>)", new Object[0]);
+        }
+
+        private void validatePathName(int i, String str) {
+            if (!ServiceMethod.PARAM_NAME_REGEX.matcher(str).matches()) {
+                throw parameterError(i, "@Path parameter name must match %s. Found: %s", ServiceMethod.PARAM_URL_REGEX.pattern(), str);
+            }
+            if (!this.relativeUrlParamNames.contains(str)) {
+                throw parameterError(i, "URL \"%s\" does not contain \"{%s}\".", this.relativeUrl, str);
+            }
+        }
+
+        public ServiceMethod build() {
+            this.callAdapter = createCallAdapter();
+            this.responseType = this.callAdapter.responseType();
+            Type type = this.responseType;
+            if (type == Response.class || type == okhttp3.Response.class) {
+                throw methodError("'" + Utils.getRawType(this.responseType).getName() + "' is not a valid response body type. Did you mean ResponseBody?", new Object[0]);
+            }
+            this.responseConverter = createResponseConverter();
+            for (Annotation annotation : this.methodAnnotations) {
+                parseMethodAnnotation(annotation);
+            }
+            if (this.httpMethod == null) {
+                throw methodError("HTTP method annotation is required (e.g., @GET, @POST, etc.).", new Object[0]);
+            }
+            if (!this.hasBody) {
+                if (this.isMultipart) {
+                    throw methodError("Multipart can only be specified on HTTP methods with request body (e.g., @POST).", new Object[0]);
+                }
+                if (this.isFormEncoded) {
+                    throw methodError("FormUrlEncoded can only be specified on HTTP methods with request body (e.g., @POST).", new Object[0]);
+                }
+            }
+            int length = this.parameterAnnotationsArray.length;
+            this.parameterHandlers = new ParameterHandler[length];
+            for (int i = 0; i < length; i++) {
+                Type type2 = this.parameterTypes[i];
+                if (Utils.hasUnresolvableType(type2)) {
+                    throw parameterError(i, "Parameter type must not include a type variable or wildcard: %s", type2);
+                }
+                Annotation[] annotationArr = this.parameterAnnotationsArray[i];
+                if (annotationArr == null) {
+                    throw parameterError(i, "No Retrofit annotation found.", new Object[0]);
+                }
+                this.parameterHandlers[i] = parseParameter(i, type2, annotationArr);
+            }
+            if (this.relativeUrl == null && !this.gotUrl) {
+                throw methodError("Missing either @%s URL or @Url parameter.", this.httpMethod);
+            }
+            if (!this.isFormEncoded && !this.isMultipart && !this.hasBody && this.gotBody) {
+                throw methodError("Non-body HTTP method cannot contain @Body.", new Object[0]);
+            }
+            if (this.isFormEncoded && !this.gotField) {
+                throw methodError("Form-encoded method must contain at least one @Field.", new Object[0]);
+            }
+            if (!this.isMultipart || this.gotPart) {
+                return new ServiceMethod(this);
+            }
+            throw methodError("Multipart method must contain at least one @Part.", new Object[0]);
+        }
+
+        private RuntimeException methodError(Throwable th, String str, Object... objArr) {
+            return new IllegalArgumentException(String.format(str, objArr) + "\n    for method " + this.method.getDeclaringClass().getSimpleName() + "." + this.method.getName(), th);
+        }
+
+        private RuntimeException parameterError(int i, String str, Object... objArr) {
+            return methodError(str + " (parameter #" + (i + 1) + ")", objArr);
+        }
+    }
+
+    ServiceMethod(Builder<R, T> builder) {
+        this.callFactory = builder.retrofit.callFactory();
+        this.callAdapter = builder.callAdapter;
+        this.baseUrl = builder.retrofit.baseUrl();
+        this.responseConverter = builder.responseConverter;
+        this.httpMethod = builder.httpMethod;
+        this.relativeUrl = builder.relativeUrl;
+        this.headers = builder.headers;
+        this.contentType = builder.contentType;
+        this.hasBody = builder.hasBody;
+        this.isFormEncoded = builder.isFormEncoded;
+        this.isMultipart = builder.isMultipart;
+        this.parameterHandlers = builder.parameterHandlers;
+    }
+
+    static Class<?> boxIfPrimitive(Class<?> cls) {
+        return Boolean.TYPE == cls ? Boolean.class : Byte.TYPE == cls ? Byte.class : Character.TYPE == cls ? Character.class : Double.TYPE == cls ? Double.class : Float.TYPE == cls ? Float.class : Integer.TYPE == cls ? Integer.class : Long.TYPE == cls ? Long.class : Short.TYPE == cls ? Short.class : cls;
+    }
+
+    static Set<String> parsePathParameters(String str) {
+        Matcher matcher = PARAM_URL_REGEX.matcher(str);
+        LinkedHashSet linkedHashSet = new LinkedHashSet();
+        while (matcher.find()) {
+            linkedHashSet.add(matcher.group(1));
+        }
+        return linkedHashSet;
+    }
+
+    T adapt(Call<R> call) {
+        return this.callAdapter.adapt(call);
+    }
+
+    okhttp3.Call toCall(Object... objArr) throws IOException {
+        RequestBuilder requestBuilder = new RequestBuilder(this.httpMethod, this.baseUrl, this.relativeUrl, this.headers, this.contentType, this.hasBody, this.isFormEncoded, this.isMultipart);
+        ParameterHandler<?>[] parameterHandlerArr = this.parameterHandlers;
+        int length = objArr != null ? objArr.length : 0;
+        if (length == parameterHandlerArr.length) {
+            for (int i = 0; i < length; i++) {
+                parameterHandlerArr[i].apply(requestBuilder, objArr[i]);
+            }
+            return this.callFactory.newCall(requestBuilder.build());
+        }
+        throw new IllegalArgumentException("Argument count (" + length + ") doesn't match expected count (" + parameterHandlerArr.length + ")");
+    }
+
+    R toResponse(ResponseBody responseBody) throws IOException {
+        return this.responseConverter.convert(responseBody);
+    }
+}

sources/retrofit2/Utils.java

@@ -0,0 +1,461 @@
+package retrofit2;
+
+import java.io.IOException;
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Array;
+import java.lang.reflect.GenericArrayType;
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Type;
+import java.lang.reflect.TypeVariable;
+import java.lang.reflect.WildcardType;
+import java.util.Arrays;
+import java.util.NoSuchElementException;
+import okhttp3.ResponseBody;
+import okio.Buffer;
+
+/* loaded from: classes2.dex */
+final class Utils {
+    static final Type[] EMPTY_TYPE_ARRAY = new Type[0];
+
+    private static final class GenericArrayTypeImpl implements GenericArrayType {
+        private final Type componentType;
+
+        GenericArrayTypeImpl(Type type) {
+            this.componentType = type;
+        }
+
+        public boolean equals(Object obj) {
+            return (obj instanceof GenericArrayType) && Utils.equals(this, (GenericArrayType) obj);
+        }
+
+        @Override // java.lang.reflect.GenericArrayType
+        public Type getGenericComponentType() {
+            return this.componentType;
+        }
+
+        public int hashCode() {
+            return this.componentType.hashCode();
+        }
+
+        public String toString() {
+            return Utils.typeToString(this.componentType) + "[]";
+        }
+    }
+
+    private static final class ParameterizedTypeImpl implements ParameterizedType {
+        private final Type ownerType;
+        private final Type rawType;
+        private final Type[] typeArguments;
+
+        ParameterizedTypeImpl(Type type, Type type2, Type... typeArr) {
+            if (type2 instanceof Class) {
+                if ((type == null) != (((Class) type2).getEnclosingClass() == null)) {
+                    throw new IllegalArgumentException();
+                }
+            }
+            for (Type type3 : typeArr) {
+                Utils.checkNotNull(type3, "typeArgument == null");
+                Utils.checkNotPrimitive(type3);
+            }
+            this.ownerType = type;
+            this.rawType = type2;
+            this.typeArguments = (Type[]) typeArr.clone();
+        }
+
+        public boolean equals(Object obj) {
+            return (obj instanceof ParameterizedType) && Utils.equals(this, (ParameterizedType) obj);
+        }
+
+        @Override // java.lang.reflect.ParameterizedType
+        public Type[] getActualTypeArguments() {
+            return (Type[]) this.typeArguments.clone();
+        }
+
+        @Override // java.lang.reflect.ParameterizedType
+        public Type getOwnerType() {
+            return this.ownerType;
+        }
+
+        @Override // java.lang.reflect.ParameterizedType
+        public Type getRawType() {
+            return this.rawType;
+        }
+
+        public int hashCode() {
+            int hashCode = Arrays.hashCode(this.typeArguments) ^ this.rawType.hashCode();
+            Type type = this.ownerType;
+            return hashCode ^ (type != null ? type.hashCode() : 0);
+        }
+
+        public String toString() {
+            Type[] typeArr = this.typeArguments;
+            if (typeArr.length == 0) {
+                return Utils.typeToString(this.rawType);
+            }
+            StringBuilder sb = new StringBuilder((typeArr.length + 1) * 30);
+            sb.append(Utils.typeToString(this.rawType));
+            sb.append("<");
+            sb.append(Utils.typeToString(this.typeArguments[0]));
+            for (int i = 1; i < this.typeArguments.length; i++) {
+                sb.append(", ");
+                sb.append(Utils.typeToString(this.typeArguments[i]));
+            }
+            sb.append(">");
+            return sb.toString();
+        }
+    }
+
+    private static final class WildcardTypeImpl implements WildcardType {
+        private final Type lowerBound;
+        private final Type upperBound;
+
+        WildcardTypeImpl(Type[] typeArr, Type[] typeArr2) {
+            if (typeArr2.length > 1) {
+                throw new IllegalArgumentException();
+            }
+            if (typeArr.length != 1) {
+                throw new IllegalArgumentException();
+            }
+            if (typeArr2.length != 1) {
+                if (typeArr[0] == null) {
+                    throw new NullPointerException();
+                }
+                Utils.checkNotPrimitive(typeArr[0]);
+                this.lowerBound = null;
+                this.upperBound = typeArr[0];
+                return;
+            }
+            if (typeArr2[0] == null) {
+                throw new NullPointerException();
+            }
+            Utils.checkNotPrimitive(typeArr2[0]);
+            if (typeArr[0] != Object.class) {
+                throw new IllegalArgumentException();
+            }
+            this.lowerBound = typeArr2[0];
+            this.upperBound = Object.class;
+        }
+
+        public boolean equals(Object obj) {
+            return (obj instanceof WildcardType) && Utils.equals(this, (WildcardType) obj);
+        }
+
+        @Override // java.lang.reflect.WildcardType
+        public Type[] getLowerBounds() {
+            Type type = this.lowerBound;
+            return type != null ? new Type[]{type} : Utils.EMPTY_TYPE_ARRAY;
+        }
+
+        @Override // java.lang.reflect.WildcardType
+        public Type[] getUpperBounds() {
+            return new Type[]{this.upperBound};
+        }
+
+        public int hashCode() {
+            Type type = this.lowerBound;
+            return (type != null ? type.hashCode() + 31 : 1) ^ (this.upperBound.hashCode() + 31);
+        }
+
+        public String toString() {
+            if (this.lowerBound != null) {
+                return "? super " + Utils.typeToString(this.lowerBound);
+            }
+            if (this.upperBound == Object.class) {
+                return "?";
+            }
+            return "? extends " + Utils.typeToString(this.upperBound);
+        }
+    }
+
+    private Utils() {
+    }
+
+    static ResponseBody buffer(ResponseBody responseBody) throws IOException {
+        Buffer buffer = new Buffer();
+        responseBody.source().readAll(buffer);
+        return ResponseBody.create(responseBody.contentType(), responseBody.contentLength(), buffer);
+    }
+
+    static <T> T checkNotNull(T t, String str) {
+        if (t != null) {
+            return t;
+        }
+        throw new NullPointerException(str);
+    }
+
+    static void checkNotPrimitive(Type type) {
+        if ((type instanceof Class) && ((Class) type).isPrimitive()) {
+            throw new IllegalArgumentException();
+        }
+    }
+
+    private static Class<?> declaringClassOf(TypeVariable<?> typeVariable) {
+        Object genericDeclaration = typeVariable.getGenericDeclaration();
+        if (genericDeclaration instanceof Class) {
+            return (Class) genericDeclaration;
+        }
+        return null;
+    }
+
+    static boolean equals(Type type, Type type2) {
+        if (type == type2) {
+            return true;
+        }
+        if (type instanceof Class) {
+            return type.equals(type2);
+        }
+        if (type instanceof ParameterizedType) {
+            if (!(type2 instanceof ParameterizedType)) {
+                return false;
+            }
+            ParameterizedType parameterizedType = (ParameterizedType) type;
+            ParameterizedType parameterizedType2 = (ParameterizedType) type2;
+            Type ownerType = parameterizedType.getOwnerType();
+            Type ownerType2 = parameterizedType2.getOwnerType();
+            return (ownerType == ownerType2 || (ownerType != null && ownerType.equals(ownerType2))) && parameterizedType.getRawType().equals(parameterizedType2.getRawType()) && Arrays.equals(parameterizedType.getActualTypeArguments(), parameterizedType2.getActualTypeArguments());
+        }
+        if (type instanceof GenericArrayType) {
+            if (type2 instanceof GenericArrayType) {
+                return equals(((GenericArrayType) type).getGenericComponentType(), ((GenericArrayType) type2).getGenericComponentType());
+            }
+            return false;
+        }
+        if (type instanceof WildcardType) {
+            if (!(type2 instanceof WildcardType)) {
+                return false;
+            }
+            WildcardType wildcardType = (WildcardType) type;
+            WildcardType wildcardType2 = (WildcardType) type2;
+            return Arrays.equals(wildcardType.getUpperBounds(), wildcardType2.getUpperBounds()) && Arrays.equals(wildcardType.getLowerBounds(), wildcardType2.getLowerBounds());
+        }
+        if (!(type instanceof TypeVariable) || !(type2 instanceof TypeVariable)) {
+            return false;
+        }
+        TypeVariable typeVariable = (TypeVariable) type;
+        TypeVariable typeVariable2 = (TypeVariable) type2;
+        return typeVariable.getGenericDeclaration() == typeVariable2.getGenericDeclaration() && typeVariable.getName().equals(typeVariable2.getName());
+    }
+
+    static Type getCallResponseType(Type type) {
+        if (type instanceof ParameterizedType) {
+            return getParameterUpperBound(0, (ParameterizedType) type);
+        }
+        throw new IllegalArgumentException("Call return type must be parameterized as Call<Foo> or Call<? extends Foo>");
+    }
+
+    static Type getGenericSupertype(Type type, Class<?> cls, Class<?> cls2) {
+        if (cls2 == cls) {
+            return type;
+        }
+        if (cls2.isInterface()) {
+            Class<?>[] interfaces = cls.getInterfaces();
+            int length = interfaces.length;
+            for (int i = 0; i < length; i++) {
+                if (interfaces[i] == cls2) {
+                    return cls.getGenericInterfaces()[i];
+                }
+                if (cls2.isAssignableFrom(interfaces[i])) {
+                    return getGenericSupertype(cls.getGenericInterfaces()[i], interfaces[i], cls2);
+                }
+            }
+        }
+        if (!cls.isInterface()) {
+            while (cls != Object.class) {
+                Class<? super Object> superclass = cls.getSuperclass();
+                if (superclass == cls2) {
+                    return cls.getGenericSuperclass();
+                }
+                if (cls2.isAssignableFrom(superclass)) {
+                    return getGenericSupertype(cls.getGenericSuperclass(), superclass, cls2);
+                }
+                cls = superclass;
+            }
+        }
+        return cls2;
+    }
+
+    static Type getParameterUpperBound(int i, ParameterizedType parameterizedType) {
+        Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
+        if (i >= 0 && i < actualTypeArguments.length) {
+            Type type = actualTypeArguments[i];
+            return type instanceof WildcardType ? ((WildcardType) type).getUpperBounds()[0] : type;
+        }
+        throw new IllegalArgumentException("Index " + i + " not in range [0," + actualTypeArguments.length + ") for " + parameterizedType);
+    }
+
+    static Class<?> getRawType(Type type) {
+        checkNotNull(type, "type == null");
+        if (type instanceof Class) {
+            return (Class) type;
+        }
+        if (type instanceof ParameterizedType) {
+            Type rawType = ((ParameterizedType) type).getRawType();
+            if (rawType instanceof Class) {
+                return (Class) rawType;
+            }
+            throw new IllegalArgumentException();
+        }
+        if (type instanceof GenericArrayType) {
+            return Array.newInstance(getRawType(((GenericArrayType) type).getGenericComponentType()), 0).getClass();
+        }
+        if (type instanceof TypeVariable) {
+            return Object.class;
+        }
+        if (type instanceof WildcardType) {
+            return getRawType(((WildcardType) type).getUpperBounds()[0]);
+        }
+        throw new IllegalArgumentException("Expected a Class, ParameterizedType, or GenericArrayType, but <" + type + "> is of type " + type.getClass().getName());
+    }
+
+    static Type getSupertype(Type type, Class<?> cls, Class<?> cls2) {
+        if (cls2.isAssignableFrom(cls)) {
+            return resolve(type, cls, getGenericSupertype(type, cls, cls2));
+        }
+        throw new IllegalArgumentException();
+    }
+
+    static boolean hasUnresolvableType(Type type) {
+        if (type instanceof Class) {
+            return false;
+        }
+        if (type instanceof ParameterizedType) {
+            for (Type type2 : ((ParameterizedType) type).getActualTypeArguments()) {
+                if (hasUnresolvableType(type2)) {
+                    return true;
+                }
+            }
+            return false;
+        }
+        if (type instanceof GenericArrayType) {
+            return hasUnresolvableType(((GenericArrayType) type).getGenericComponentType());
+        }
+        if ((type instanceof TypeVariable) || (type instanceof WildcardType)) {
+            return true;
+        }
+        throw new IllegalArgumentException("Expected a Class, ParameterizedType, or GenericArrayType, but <" + type + "> is of type " + (type == null ? "null" : type.getClass().getName()));
+    }
+
+    private static int indexOf(Object[] objArr, Object obj) {
+        for (int i = 0; i < objArr.length; i++) {
+            if (obj.equals(objArr[i])) {
+                return i;
+            }
+        }
+        throw new NoSuchElementException();
+    }
+
+    static boolean isAnnotationPresent(Annotation[] annotationArr, Class<? extends Annotation> cls) {
+        for (Annotation annotation : annotationArr) {
+            if (cls.isInstance(annotation)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    static Type resolve(Type type, Class<?> cls, Type type2) {
+        Type type3 = type2;
+        while (type3 instanceof TypeVariable) {
+            TypeVariable typeVariable = (TypeVariable) type3;
+            Type resolveTypeVariable = resolveTypeVariable(type, cls, typeVariable);
+            if (resolveTypeVariable == typeVariable) {
+                return resolveTypeVariable;
+            }
+            type3 = resolveTypeVariable;
+        }
+        if (type3 instanceof Class) {
+            Class cls2 = (Class) type3;
+            if (cls2.isArray()) {
+                Class<?> componentType = cls2.getComponentType();
+                Type resolve = resolve(type, cls, componentType);
+                return componentType == resolve ? cls2 : new GenericArrayTypeImpl(resolve);
+            }
+        }
+        if (type3 instanceof GenericArrayType) {
+            GenericArrayType genericArrayType = (GenericArrayType) type3;
+            Type genericComponentType = genericArrayType.getGenericComponentType();
+            Type resolve2 = resolve(type, cls, genericComponentType);
+            return genericComponentType == resolve2 ? genericArrayType : new GenericArrayTypeImpl(resolve2);
+        }
+        if (type3 instanceof ParameterizedType) {
+            ParameterizedType parameterizedType = (ParameterizedType) type3;
+            Type ownerType = parameterizedType.getOwnerType();
+            Type resolve3 = resolve(type, cls, ownerType);
+            boolean z = resolve3 != ownerType;
+            Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
+            int length = actualTypeArguments.length;
+            for (int i = 0; i < length; i++) {
+                Type resolve4 = resolve(type, cls, actualTypeArguments[i]);
+                if (resolve4 != actualTypeArguments[i]) {
+                    if (!z) {
+                        actualTypeArguments = (Type[]) actualTypeArguments.clone();
+                        z = true;
+                    }
+                    actualTypeArguments[i] = resolve4;
+                }
+            }
+            return z ? new ParameterizedTypeImpl(resolve3, parameterizedType.getRawType(), actualTypeArguments) : parameterizedType;
+        }
+        boolean z2 = type3 instanceof WildcardType;
+        Type type4 = type3;
+        if (z2) {
+            WildcardType wildcardType = (WildcardType) type3;
+            Type[] lowerBounds = wildcardType.getLowerBounds();
+            Type[] upperBounds = wildcardType.getUpperBounds();
+            if (lowerBounds.length == 1) {
+                Type resolve5 = resolve(type, cls, lowerBounds[0]);
+                type4 = wildcardType;
+                if (resolve5 != lowerBounds[0]) {
+                    return new WildcardTypeImpl(new Type[]{Object.class}, new Type[]{resolve5});
+                }
+            } else {
+                type4 = wildcardType;
+                if (upperBounds.length == 1) {
+                    Type resolve6 = resolve(type, cls, upperBounds[0]);
+                    type4 = wildcardType;
+                    if (resolve6 != upperBounds[0]) {
+                        return new WildcardTypeImpl(new Type[]{resolve6}, EMPTY_TYPE_ARRAY);
+                    }
+                }
+            }
+        }
+        return type4;
+    }
+
+    private static Type resolveTypeVariable(Type type, Class<?> cls, TypeVariable<?> typeVariable) {
+        Class<?> declaringClassOf = declaringClassOf(typeVariable);
+        if (declaringClassOf == null) {
+            return typeVariable;
+        }
+        Type genericSupertype = getGenericSupertype(type, cls, declaringClassOf);
+        if (!(genericSupertype instanceof ParameterizedType)) {
+            return typeVariable;
+        }
+        return ((ParameterizedType) genericSupertype).getActualTypeArguments()[indexOf(declaringClassOf.getTypeParameters(), typeVariable)];
+    }
+
+    static void throwIfFatal(Throwable th) {
+        if (th instanceof VirtualMachineError) {
+            throw ((VirtualMachineError) th);
+        }
+        if (th instanceof ThreadDeath) {
+            throw ((ThreadDeath) th);
+        }
+        if (th instanceof LinkageError) {
+            throw ((LinkageError) th);
+        }
+    }
+
+    static String typeToString(Type type) {
+        return type instanceof Class ? ((Class) type).getName() : type.toString();
+    }
+
+    static <T> void validateServiceInterface(Class<T> cls) {
+        if (!cls.isInterface()) {
+            throw new IllegalArgumentException("API declarations must be interfaces.");
+        }
+        if (cls.getInterfaces().length > 0) {
+            throw new IllegalArgumentException("API interfaces must not extend other interfaces.");
+        }
+    }
+}

sources/retrofit2/adapter/rxjava2/BodyObservable.java

@@ -0,0 +1,72 @@
+package retrofit2.adapter.rxjava2;
+
+import io.reactivex.Observable;
+import io.reactivex.Observer;
+import io.reactivex.disposables.Disposable;
+import io.reactivex.exceptions.CompositeException;
+import io.reactivex.exceptions.Exceptions;
+import io.reactivex.plugins.RxJavaPlugins;
+import retrofit2.Response;
+
+/* loaded from: classes2.dex */
+final class BodyObservable<T> extends Observable<T> {
+    private final Observable<Response<T>> upstream;
+
+    private static class BodyObserver<R> implements Observer<Response<R>> {
+        private final Observer<? super R> observer;
+        private boolean terminated;
+
+        BodyObserver(Observer<? super R> observer) {
+            this.observer = observer;
+        }
+
+        @Override // io.reactivex.Observer
+        public void onComplete() {
+            if (this.terminated) {
+                return;
+            }
+            this.observer.onComplete();
+        }
+
+        @Override // io.reactivex.Observer
+        public void onError(Throwable th) {
+            if (!this.terminated) {
+                this.observer.onError(th);
+                return;
+            }
+            AssertionError assertionError = new AssertionError("This should never happen! Report as a bug with the full stacktrace.");
+            assertionError.initCause(th);
+            RxJavaPlugins.b(assertionError);
+        }
+
+        @Override // io.reactivex.Observer
+        public void onSubscribe(Disposable disposable) {
+            this.observer.onSubscribe(disposable);
+        }
+
+        @Override // io.reactivex.Observer
+        public void onNext(Response<R> response) {
+            if (response.isSuccessful()) {
+                this.observer.onNext(response.body());
+                return;
+            }
+            this.terminated = true;
+            HttpException httpException = new HttpException(response);
+            try {
+                this.observer.onError(httpException);
+            } catch (Throwable th) {
+                Exceptions.b(th);
+                RxJavaPlugins.b(new CompositeException(httpException, th));
+            }
+        }
+    }
+
+    BodyObservable(Observable<Response<T>> observable) {
+        this.upstream = observable;
+    }
+
+    @Override // io.reactivex.Observable
+    protected void subscribeActual(Observer<? super T> observer) {
+        this.upstream.subscribe(new BodyObserver(observer));
+    }
+}

sources/retrofit2/adapter/rxjava2/CallEnqueueObservable.java

@@ -0,0 +1,90 @@
+package retrofit2.adapter.rxjava2;
+
+import io.reactivex.Observable;
+import io.reactivex.Observer;
+import io.reactivex.disposables.Disposable;
+import io.reactivex.exceptions.CompositeException;
+import io.reactivex.exceptions.Exceptions;
+import io.reactivex.plugins.RxJavaPlugins;
+import retrofit2.Call;
+import retrofit2.Callback;
+import retrofit2.Response;
+
+/* loaded from: classes2.dex */
+final class CallEnqueueObservable<T> extends Observable<Response<T>> {
+    private final Call<T> originalCall;
+
+    private static final class CallCallback<T> implements Disposable, Callback<T> {
+        private final Call<?> call;
+        private final Observer<? super Response<T>> observer;
+        boolean terminated = false;
+
+        CallCallback(Call<?> call, Observer<? super Response<T>> observer) {
+            this.call = call;
+            this.observer = observer;
+        }
+
+        @Override // io.reactivex.disposables.Disposable
+        public void dispose() {
+            this.call.cancel();
+        }
+
+        public boolean isDisposed() {
+            return this.call.isCanceled();
+        }
+
+        @Override // retrofit2.Callback
+        public void onFailure(Call<T> call, Throwable th) {
+            if (call.isCanceled()) {
+                return;
+            }
+            try {
+                this.observer.onError(th);
+            } catch (Throwable th2) {
+                Exceptions.b(th2);
+                RxJavaPlugins.b(new CompositeException(th, th2));
+            }
+        }
+
+        @Override // retrofit2.Callback
+        public void onResponse(Call<T> call, Response<T> response) {
+            if (call.isCanceled()) {
+                return;
+            }
+            try {
+                this.observer.onNext(response);
+                if (call.isCanceled()) {
+                    return;
+                }
+                this.terminated = true;
+                this.observer.onComplete();
+            } catch (Throwable th) {
+                if (this.terminated) {
+                    RxJavaPlugins.b(th);
+                    return;
+                }
+                if (call.isCanceled()) {
+                    return;
+                }
+                try {
+                    this.observer.onError(th);
+                } catch (Throwable th2) {
+                    Exceptions.b(th2);
+                    RxJavaPlugins.b(new CompositeException(th, th2));
+                }
+            }
+        }
+    }
+
+    CallEnqueueObservable(Call<T> call) {
+        this.originalCall = call;
+    }
+
+    @Override // io.reactivex.Observable
+    protected void subscribeActual(Observer<? super Response<T>> observer) {
+        Call<T> clone = this.originalCall.clone();
+        CallCallback callCallback = new CallCallback(clone, observer);
+        observer.onSubscribe(callCallback);
+        clone.enqueue(callCallback);
+    }
+}

sources/retrofit2/adapter/rxjava2/CallExecuteObservable.java

@@ -0,0 +1,75 @@
+package retrofit2.adapter.rxjava2;
+
+import io.reactivex.Observable;
+import io.reactivex.Observer;
+import io.reactivex.disposables.Disposable;
+import io.reactivex.exceptions.CompositeException;
+import io.reactivex.exceptions.Exceptions;
+import io.reactivex.plugins.RxJavaPlugins;
+import retrofit2.Call;
+import retrofit2.Response;
+
+/* loaded from: classes2.dex */
+final class CallExecuteObservable<T> extends Observable<Response<T>> {
+    private final Call<T> originalCall;
+
+    private static final class CallDisposable implements Disposable {
+        private final Call<?> call;
+
+        CallDisposable(Call<?> call) {
+            this.call = call;
+        }
+
+        @Override // io.reactivex.disposables.Disposable
+        public void dispose() {
+            this.call.cancel();
+        }
+
+        public boolean isDisposed() {
+            return this.call.isCanceled();
+        }
+    }
+
+    CallExecuteObservable(Call<T> call) {
+        this.originalCall = call;
+    }
+
+    @Override // io.reactivex.Observable
+    protected void subscribeActual(Observer<? super Response<T>> observer) {
+        boolean z;
+        Call<T> clone = this.originalCall.clone();
+        observer.onSubscribe(new CallDisposable(clone));
+        try {
+            Response<T> execute = clone.execute();
+            if (!clone.isCanceled()) {
+                observer.onNext(execute);
+            }
+            if (clone.isCanceled()) {
+                return;
+            }
+            try {
+                observer.onComplete();
+            } catch (Throwable th) {
+                th = th;
+                z = true;
+                Exceptions.b(th);
+                if (z) {
+                    RxJavaPlugins.b(th);
+                    return;
+                }
+                if (clone.isCanceled()) {
+                    return;
+                }
+                try {
+                    observer.onError(th);
+                } catch (Throwable th2) {
+                    Exceptions.b(th2);
+                    RxJavaPlugins.b(new CompositeException(th, th2));
+                }
+            }
+        } catch (Throwable th3) {
+            th = th3;
+            z = false;
+        }
+    }
+}

sources/retrofit2/adapter/rxjava2/HttpException.java

@@ -0,0 +1,11 @@
+package retrofit2.adapter.rxjava2;
+
+import retrofit2.Response;
+
+@Deprecated
+/* loaded from: classes2.dex */
+public final class HttpException extends retrofit2.HttpException {
+    public HttpException(Response<?> response) {
+        super(response);
+    }
+}

sources/retrofit2/adapter/rxjava2/Result.java

@@ -0,0 +1,40 @@
+package retrofit2.adapter.rxjava2;
+
+import retrofit2.Response;
+
+/* loaded from: classes2.dex */
+public final class Result<T> {
+    private final Throwable error;
+    private final Response<T> response;
+
+    private Result(Response<T> response, Throwable th) {
+        this.response = response;
+        this.error = th;
+    }
+
+    public static <T> Result<T> error(Throwable th) {
+        if (th != null) {
+            return new Result<>(null, th);
+        }
+        throw new NullPointerException("error == null");
+    }
+
+    public static <T> Result<T> response(Response<T> response) {
+        if (response != null) {
+            return new Result<>(response, null);
+        }
+        throw new NullPointerException("response == null");
+    }
+
+    public boolean isError() {
+        return this.error != null;
+    }
+
+    public Throwable error() {
+        return this.error;
+    }
+
+    public Response<T> response() {
+        return this.response;
+    }
+}

sources/retrofit2/adapter/rxjava2/ResultObservable.java

@@ -0,0 +1,61 @@
+package retrofit2.adapter.rxjava2;
+
+import io.reactivex.Observable;
+import io.reactivex.Observer;
+import io.reactivex.disposables.Disposable;
+import io.reactivex.exceptions.CompositeException;
+import io.reactivex.exceptions.Exceptions;
+import io.reactivex.plugins.RxJavaPlugins;
+import retrofit2.Response;
+
+/* loaded from: classes2.dex */
+final class ResultObservable<T> extends Observable<Result<T>> {
+    private final Observable<Response<T>> upstream;
+
+    private static class ResultObserver<R> implements Observer<Response<R>> {
+        private final Observer<? super Result<R>> observer;
+
+        ResultObserver(Observer<? super Result<R>> observer) {
+            this.observer = observer;
+        }
+
+        @Override // io.reactivex.Observer
+        public void onComplete() {
+            this.observer.onComplete();
+        }
+
+        @Override // io.reactivex.Observer
+        public void onError(Throwable th) {
+            try {
+                this.observer.onNext(Result.error(th));
+                this.observer.onComplete();
+            } catch (Throwable th2) {
+                try {
+                    this.observer.onError(th2);
+                } catch (Throwable th3) {
+                    Exceptions.b(th3);
+                    RxJavaPlugins.b(new CompositeException(th2, th3));
+                }
+            }
+        }
+
+        @Override // io.reactivex.Observer
+        public void onSubscribe(Disposable disposable) {
+            this.observer.onSubscribe(disposable);
+        }
+
+        @Override // io.reactivex.Observer
+        public void onNext(Response<R> response) {
+            this.observer.onNext(Result.response(response));
+        }
+    }
+
+    ResultObservable(Observable<Response<T>> observable) {
+        this.upstream = observable;
+    }
+
+    @Override // io.reactivex.Observable
+    protected void subscribeActual(Observer<? super Result<T>> observer) {
+        this.upstream.subscribe(new ResultObserver(observer));
+    }
+}

sources/retrofit2/adapter/rxjava2/RxJava2CallAdapter.java

@@ -0,0 +1,49 @@
+package retrofit2.adapter.rxjava2;
+
+import io.reactivex.BackpressureStrategy;
+import io.reactivex.Observable;
+import io.reactivex.Scheduler;
+import java.lang.reflect.Type;
+import retrofit2.Call;
+import retrofit2.CallAdapter;
+
+/* loaded from: classes2.dex */
+final class RxJava2CallAdapter<R> implements CallAdapter<R, Object> {
+    private final boolean isAsync;
+    private final boolean isBody;
+    private final boolean isCompletable;
+    private final boolean isFlowable;
+    private final boolean isMaybe;
+    private final boolean isResult;
+    private final boolean isSingle;
+    private final Type responseType;
+    private final Scheduler scheduler;
+
+    RxJava2CallAdapter(Type type, Scheduler scheduler, boolean z, boolean z2, boolean z3, boolean z4, boolean z5, boolean z6, boolean z7) {
+        this.responseType = type;
+        this.scheduler = scheduler;
+        this.isAsync = z;
+        this.isResult = z2;
+        this.isBody = z3;
+        this.isFlowable = z4;
+        this.isSingle = z5;
+        this.isMaybe = z6;
+        this.isCompletable = z7;
+    }
+
+    @Override // retrofit2.CallAdapter
+    public Object adapt(Call<R> call) {
+        Observable callEnqueueObservable = this.isAsync ? new CallEnqueueObservable(call) : new CallExecuteObservable(call);
+        Observable resultObservable = this.isResult ? new ResultObservable(callEnqueueObservable) : this.isBody ? new BodyObservable(callEnqueueObservable) : callEnqueueObservable;
+        Scheduler scheduler = this.scheduler;
+        if (scheduler != null) {
+            resultObservable = resultObservable.subscribeOn(scheduler);
+        }
+        return this.isFlowable ? resultObservable.toFlowable(BackpressureStrategy.LATEST) : this.isSingle ? resultObservable.singleOrError() : this.isMaybe ? resultObservable.singleElement() : this.isCompletable ? resultObservable.ignoreElements() : resultObservable;
+    }
+
+    @Override // retrofit2.CallAdapter
+    public Type responseType() {
+        return this.responseType;
+    }
+}

sources/retrofit2/adapter/rxjava2/RxJava2CallAdapterFactory.java

@@ -0,0 +1,84 @@
+package retrofit2.adapter.rxjava2;
+
+import io.reactivex.Completable;
+import io.reactivex.Flowable;
+import io.reactivex.Maybe;
+import io.reactivex.Observable;
+import io.reactivex.Scheduler;
+import io.reactivex.Single;
+import java.lang.annotation.Annotation;
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Type;
+import retrofit2.CallAdapter;
+import retrofit2.Response;
+import retrofit2.Retrofit;
+
+/* loaded from: classes2.dex */
+public final class RxJava2CallAdapterFactory extends CallAdapter.Factory {
+    private final boolean isAsync;
+    private final Scheduler scheduler;
+
+    private RxJava2CallAdapterFactory(Scheduler scheduler, boolean z) {
+        this.scheduler = scheduler;
+        this.isAsync = z;
+    }
+
+    public static RxJava2CallAdapterFactory create() {
+        return new RxJava2CallAdapterFactory(null, false);
+    }
+
+    public static RxJava2CallAdapterFactory createAsync() {
+        return new RxJava2CallAdapterFactory(null, true);
+    }
+
+    public static RxJava2CallAdapterFactory createWithScheduler(Scheduler scheduler) {
+        if (scheduler != null) {
+            return new RxJava2CallAdapterFactory(scheduler, false);
+        }
+        throw new NullPointerException("scheduler == null");
+    }
+
+    @Override // retrofit2.CallAdapter.Factory
+    public CallAdapter<?, ?> get(Type type, Annotation[] annotationArr, Retrofit retrofit) {
+        Type type2;
+        boolean z;
+        boolean z2;
+        Class<?> rawType = CallAdapter.Factory.getRawType(type);
+        if (rawType == Completable.class) {
+            return new RxJava2CallAdapter(Void.class, this.scheduler, this.isAsync, false, true, false, false, false, true);
+        }
+        boolean z3 = rawType == Flowable.class;
+        boolean z4 = rawType == Single.class;
+        boolean z5 = rawType == Maybe.class;
+        if (rawType != Observable.class && !z3 && !z4 && !z5) {
+            return null;
+        }
+        if (!(type instanceof ParameterizedType)) {
+            String str = !z3 ? !z4 ? z5 ? "Maybe" : "Observable" : "Single" : "Flowable";
+            throw new IllegalStateException(str + " return type must be parameterized as " + str + "<Foo> or " + str + "<? extends Foo>");
+        }
+        Type parameterUpperBound = CallAdapter.Factory.getParameterUpperBound(0, (ParameterizedType) type);
+        Class<?> rawType2 = CallAdapter.Factory.getRawType(parameterUpperBound);
+        if (rawType2 == Response.class) {
+            if (!(parameterUpperBound instanceof ParameterizedType)) {
+                throw new IllegalStateException("Response must be parameterized as Response<Foo> or Response<? extends Foo>");
+            }
+            type2 = CallAdapter.Factory.getParameterUpperBound(0, (ParameterizedType) parameterUpperBound);
+            z = false;
+        } else {
+            if (rawType2 != Result.class) {
+                type2 = parameterUpperBound;
+                z = false;
+                z2 = true;
+                return new RxJava2CallAdapter(type2, this.scheduler, this.isAsync, z, z2, z3, z4, z5, false);
+            }
+            if (!(parameterUpperBound instanceof ParameterizedType)) {
+                throw new IllegalStateException("Result must be parameterized as Result<Foo> or Result<? extends Foo>");
+            }
+            type2 = CallAdapter.Factory.getParameterUpperBound(0, (ParameterizedType) parameterUpperBound);
+            z = true;
+        }
+        z2 = false;
+        return new RxJava2CallAdapter(type2, this.scheduler, this.isAsync, z, z2, z3, z4, z5, false);
+    }
+}

sources/retrofit2/adapter/rxjava2/package-info.java

@@ -0,0 +1,3 @@
+
+package retrofit2.adapter.rxjava2;
+

sources/retrofit2/converter/gson/GsonConverterFactory.java

@@ -0,0 +1,40 @@
+package retrofit2.converter.gson;
+
+import com.google.gson.Gson;
+import com.google.gson.reflect.TypeToken;
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Type;
+import okhttp3.RequestBody;
+import okhttp3.ResponseBody;
+import retrofit2.Converter;
+import retrofit2.Retrofit;
+
+/* loaded from: classes2.dex */
+public final class GsonConverterFactory extends Converter.Factory {
+    private final Gson gson;
+
+    private GsonConverterFactory(Gson gson) {
+        this.gson = gson;
+    }
+
+    public static GsonConverterFactory create() {
+        return create(new Gson());
+    }
+
+    @Override // retrofit2.Converter.Factory
+    public Converter<?, RequestBody> requestBodyConverter(Type type, Annotation[] annotationArr, Annotation[] annotationArr2, Retrofit retrofit) {
+        return new GsonRequestBodyConverter(this.gson, this.gson.getAdapter(TypeToken.get(type)));
+    }
+
+    @Override // retrofit2.Converter.Factory
+    public Converter<ResponseBody, ?> responseBodyConverter(Type type, Annotation[] annotationArr, Retrofit retrofit) {
+        return new GsonResponseBodyConverter(this.gson, this.gson.getAdapter(TypeToken.get(type)));
+    }
+
+    public static GsonConverterFactory create(Gson gson) {
+        if (gson != null) {
+            return new GsonConverterFactory(gson);
+        }
+        throw new NullPointerException("gson == null");
+    }
+}

sources/retrofit2/converter/gson/GsonRequestBodyConverter.java

@@ -0,0 +1,40 @@
+package retrofit2.converter.gson;
+
+import com.google.gson.Gson;
+import com.google.gson.TypeAdapter;
+import com.google.gson.stream.JsonWriter;
+import java.io.IOException;
+import java.io.OutputStreamWriter;
+import java.nio.charset.Charset;
+import okhttp3.MediaType;
+import okhttp3.RequestBody;
+import okio.Buffer;
+import retrofit2.Converter;
+
+/* loaded from: classes2.dex */
+final class GsonRequestBodyConverter<T> implements Converter<T, RequestBody> {
+    private static final MediaType MEDIA_TYPE = MediaType.parse("application/json; charset=UTF-8");
+    private static final Charset UTF_8 = Charset.forName("UTF-8");
+    private final TypeAdapter<T> adapter;
+    private final Gson gson;
+
+    GsonRequestBodyConverter(Gson gson, TypeAdapter<T> typeAdapter) {
+        this.gson = gson;
+        this.adapter = typeAdapter;
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    @Override // retrofit2.Converter
+    public /* bridge */ /* synthetic */ RequestBody convert(Object obj) throws IOException {
+        return convert((GsonRequestBodyConverter<T>) obj);
+    }
+
+    @Override // retrofit2.Converter
+    public RequestBody convert(T t) throws IOException {
+        Buffer buffer = new Buffer();
+        JsonWriter newJsonWriter = this.gson.newJsonWriter(new OutputStreamWriter(buffer.outputStream(), UTF_8));
+        this.adapter.write(newJsonWriter, t);
+        newJsonWriter.close();
+        return RequestBody.create(MEDIA_TYPE, buffer.readByteString());
+    }
+}

sources/retrofit2/converter/gson/GsonResponseBodyConverter.java

@@ -0,0 +1,35 @@
+package retrofit2.converter.gson;
+
+import com.google.gson.Gson;
+import com.google.gson.JsonIOException;
+import com.google.gson.TypeAdapter;
+import com.google.gson.stream.JsonReader;
+import com.google.gson.stream.JsonToken;
+import java.io.IOException;
+import okhttp3.ResponseBody;
+import retrofit2.Converter;
+
+/* loaded from: classes2.dex */
+final class GsonResponseBodyConverter<T> implements Converter<ResponseBody, T> {
+    private final TypeAdapter<T> adapter;
+    private final Gson gson;
+
+    GsonResponseBodyConverter(Gson gson, TypeAdapter<T> typeAdapter) {
+        this.gson = gson;
+        this.adapter = typeAdapter;
+    }
+
+    @Override // retrofit2.Converter
+    public T convert(ResponseBody responseBody) throws IOException {
+        JsonReader newJsonReader = this.gson.newJsonReader(responseBody.charStream());
+        try {
+            T read = this.adapter.read(newJsonReader);
+            if (newJsonReader.peek() == JsonToken.END_DOCUMENT) {
+                return read;
+            }
+            throw new JsonIOException("JSON document was not fully consumed.");
+        } finally {
+            responseBody.close();
+        }
+    }
+}

sources/retrofit2/converter/gson/package-info.java

@@ -0,0 +1,3 @@
+
+package retrofit2.converter.gson;
+

sources/retrofit2/http/Body.java

@@ -0,0 +1,14 @@
+package retrofit2.http;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target({ElementType.PARAMETER})
+@Documented
+@Retention(RetentionPolicy.RUNTIME)
+/* loaded from: classes2.dex */
+public @interface Body {
+}

sources/retrofit2/http/DELETE.java

@@ -0,0 +1,15 @@
+package retrofit2.http;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target({ElementType.METHOD})
+@Documented
+@Retention(RetentionPolicy.RUNTIME)
+/* loaded from: classes2.dex */
+public @interface DELETE {
+    String value() default "";
+}

sources/retrofit2/http/Field.java

@@ -0,0 +1,17 @@
+package retrofit2.http;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target({ElementType.PARAMETER})
+@Documented
+@Retention(RetentionPolicy.RUNTIME)
+/* loaded from: classes2.dex */
+public @interface Field {
+    boolean encoded() default false;
+
+    String value();
+}

sources/retrofit2/http/FieldMap.java

@@ -0,0 +1,15 @@
+package retrofit2.http;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target({ElementType.PARAMETER})
+@Documented
+@Retention(RetentionPolicy.RUNTIME)
+/* loaded from: classes2.dex */
+public @interface FieldMap {
+    boolean encoded() default false;
+}

sources/retrofit2/http/FormUrlEncoded.java

@@ -0,0 +1,14 @@
+package retrofit2.http;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target({ElementType.METHOD})
+@Documented
+@Retention(RetentionPolicy.RUNTIME)
+/* loaded from: classes2.dex */
+public @interface FormUrlEncoded {
+}

sources/retrofit2/http/GET.java

@@ -0,0 +1,15 @@
+package retrofit2.http;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target({ElementType.METHOD})
+@Documented
+@Retention(RetentionPolicy.RUNTIME)
+/* loaded from: classes2.dex */
+public @interface GET {
+    String value() default "";
+}

sources/retrofit2/http/HEAD.java

@@ -0,0 +1,15 @@
+package retrofit2.http;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target({ElementType.METHOD})
+@Documented
+@Retention(RetentionPolicy.RUNTIME)
+/* loaded from: classes2.dex */
+public @interface HEAD {
+    String value() default "";
+}

sources/retrofit2/http/HTTP.java

@@ -0,0 +1,19 @@
+package retrofit2.http;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target({ElementType.METHOD})
+@Documented
+@Retention(RetentionPolicy.RUNTIME)
+/* loaded from: classes2.dex */
+public @interface HTTP {
+    boolean hasBody() default false;
+
+    String method();
+
+    String path() default "";
+}

sources/retrofit2/http/Header.java

@@ -0,0 +1,15 @@
+package retrofit2.http;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target({ElementType.PARAMETER})
+@Documented
+@Retention(RetentionPolicy.RUNTIME)
+/* loaded from: classes2.dex */
+public @interface Header {
+    String value();
+}

sources/retrofit2/http/HeaderMap.java

@@ -0,0 +1,14 @@
+package retrofit2.http;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target({ElementType.PARAMETER})
+@Documented
+@Retention(RetentionPolicy.RUNTIME)
+/* loaded from: classes2.dex */
+public @interface HeaderMap {
+}

sources/retrofit2/http/Headers.java

@@ -0,0 +1,15 @@
+package retrofit2.http;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target({ElementType.METHOD})
+@Documented
+@Retention(RetentionPolicy.RUNTIME)
+/* loaded from: classes2.dex */
+public @interface Headers {
+    String[] value();
+}

sources/retrofit2/http/Multipart.java

@@ -0,0 +1,14 @@
+package retrofit2.http;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target({ElementType.METHOD})
+@Documented
+@Retention(RetentionPolicy.RUNTIME)
+/* loaded from: classes2.dex */
+public @interface Multipart {
+}

sources/retrofit2/http/OPTIONS.java

@@ -0,0 +1,15 @@
+package retrofit2.http;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target({ElementType.METHOD})
+@Documented
+@Retention(RetentionPolicy.RUNTIME)
+/* loaded from: classes2.dex */
+public @interface OPTIONS {
+    String value() default "";
+}

sources/retrofit2/http/PATCH.java

@@ -0,0 +1,15 @@
+package retrofit2.http;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target({ElementType.METHOD})
+@Documented
+@Retention(RetentionPolicy.RUNTIME)
+/* loaded from: classes2.dex */
+public @interface PATCH {
+    String value() default "";
+}

sources/retrofit2/http/POST.java

@@ -0,0 +1,15 @@
+package retrofit2.http;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target({ElementType.METHOD})
+@Documented
+@Retention(RetentionPolicy.RUNTIME)
+/* loaded from: classes2.dex */
+public @interface POST {
+    String value() default "";
+}

sources/retrofit2/http/PUT.java

@@ -0,0 +1,15 @@
+package retrofit2.http;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target({ElementType.METHOD})
+@Documented
+@Retention(RetentionPolicy.RUNTIME)
+/* loaded from: classes2.dex */
+public @interface PUT {
+    String value() default "";
+}

sources/retrofit2/http/Part.java

@@ -0,0 +1,17 @@
+package retrofit2.http;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target({ElementType.PARAMETER})
+@Documented
+@Retention(RetentionPolicy.RUNTIME)
+/* loaded from: classes2.dex */
+public @interface Part {
+    String encoding() default "binary";
+
+    String value() default "";
+}

sources/retrofit2/http/PartMap.java

@@ -0,0 +1,15 @@
+package retrofit2.http;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target({ElementType.PARAMETER})
+@Documented
+@Retention(RetentionPolicy.RUNTIME)
+/* loaded from: classes2.dex */
+public @interface PartMap {
+    String encoding() default "binary";
+}

sources/retrofit2/http/Path.java

@@ -0,0 +1,17 @@
+package retrofit2.http;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target({ElementType.PARAMETER})
+@Documented
+@Retention(RetentionPolicy.RUNTIME)
+/* loaded from: classes2.dex */
+public @interface Path {
+    boolean encoded() default false;
+
+    String value();
+}

sources/retrofit2/http/Query.java

@@ -0,0 +1,17 @@
+package retrofit2.http;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target({ElementType.PARAMETER})
+@Documented
+@Retention(RetentionPolicy.RUNTIME)
+/* loaded from: classes2.dex */
+public @interface Query {
+    boolean encoded() default false;
+
+    String value();
+}

sources/retrofit2/http/QueryMap.java

@@ -0,0 +1,15 @@
+package retrofit2.http;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target({ElementType.PARAMETER})
+@Documented
+@Retention(RetentionPolicy.RUNTIME)
+/* loaded from: classes2.dex */
+public @interface QueryMap {
+    boolean encoded() default false;
+}

sources/retrofit2/http/QueryName.java

@@ -0,0 +1,15 @@
+package retrofit2.http;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target({ElementType.PARAMETER})
+@Documented
+@Retention(RetentionPolicy.RUNTIME)
+/* loaded from: classes2.dex */
+public @interface QueryName {
+    boolean encoded() default false;
+}

sources/retrofit2/http/Streaming.java

@@ -0,0 +1,14 @@
+package retrofit2.http;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target({ElementType.METHOD})
+@Documented
+@Retention(RetentionPolicy.RUNTIME)
+/* loaded from: classes2.dex */
+public @interface Streaming {
+}

sources/retrofit2/http/Url.java

@@ -0,0 +1,14 @@
+package retrofit2.http;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target({ElementType.PARAMETER})
+@Documented
+@Retention(RetentionPolicy.RUNTIME)
+/* loaded from: classes2.dex */
+public @interface Url {
+}

sources/retrofit2/package-info.java

@@ -0,0 +1,3 @@
+
+package retrofit2;
+