Initial import of ADIF API reverse-engineering toolkit

apk_decompiled/sources/retrofit2/BuiltInConverters.java

@@ -0,0 +1,108 @@
+package retrofit2;
+
+import e3.M;
+import e3.T;
+import java.io.IOException;
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Type;
+import kotlin.Unit;
+import retrofit2.Converter;
+import retrofit2.http.Streaming;
+
+/* loaded from: classes3.dex */
+final class BuiltInConverters extends Converter.Factory {
+    private boolean checkForKotlinUnit = true;
+
+    /* loaded from: classes3.dex */
+    public static final class BufferingResponseBodyConverter implements Converter<T, T> {
+        static final BufferingResponseBodyConverter INSTANCE = new BufferingResponseBodyConverter();
+
+        @Override // retrofit2.Converter
+        public T convert(T t2) throws IOException {
+            try {
+                return Utils.buffer(t2);
+            } finally {
+                t2.close();
+            }
+        }
+    }
+
+    /* loaded from: classes3.dex */
+    public static final class RequestBodyConverter implements Converter<M, M> {
+        static final RequestBodyConverter INSTANCE = new RequestBodyConverter();
+
+        @Override // retrofit2.Converter
+        public M convert(M m4) {
+            return m4;
+        }
+    }
+
+    /* loaded from: classes3.dex */
+    public static final class StreamingResponseBodyConverter implements Converter<T, T> {
+        static final StreamingResponseBodyConverter INSTANCE = new StreamingResponseBodyConverter();
+
+        @Override // retrofit2.Converter
+        public T convert(T t2) {
+            return t2;
+        }
+    }
+
+    /* loaded from: classes3.dex */
+    public static final class ToStringConverter implements Converter<Object, String> {
+        static final ToStringConverter INSTANCE = new ToStringConverter();
+
+        @Override // retrofit2.Converter
+        public String convert(Object obj) {
+            return obj.toString();
+        }
+    }
+
+    /* loaded from: classes3.dex */
+    public static final class UnitResponseBodyConverter implements Converter<T, Unit> {
+        static final UnitResponseBodyConverter INSTANCE = new UnitResponseBodyConverter();
+
+        @Override // retrofit2.Converter
+        public Unit convert(T t2) {
+            t2.close();
+            return Unit.INSTANCE;
+        }
+    }
+
+    /* loaded from: classes3.dex */
+    public static final class VoidResponseBodyConverter implements Converter<T, Void> {
+        static final VoidResponseBodyConverter INSTANCE = new VoidResponseBodyConverter();
+
+        @Override // retrofit2.Converter
+        public Void convert(T t2) {
+            t2.close();
+            return null;
+        }
+    }
+
+    @Override // retrofit2.Converter.Factory
+    public Converter<?, M> requestBodyConverter(Type type, Annotation[] annotationArr, Annotation[] annotationArr2, Retrofit retrofit) {
+        if (M.class.isAssignableFrom(Utils.getRawType(type))) {
+            return RequestBodyConverter.INSTANCE;
+        }
+        return null;
+    }
+
+    @Override // retrofit2.Converter.Factory
+    public Converter<T, ?> responseBodyConverter(Type type, Annotation[] annotationArr, Retrofit retrofit) {
+        if (type == T.class) {
+            return Utils.isAnnotationPresent(annotationArr, Streaming.class) ? StreamingResponseBodyConverter.INSTANCE : BufferingResponseBodyConverter.INSTANCE;
+        }
+        if (type == Void.class) {
+            return VoidResponseBodyConverter.INSTANCE;
+        }
+        if (!this.checkForKotlinUnit || type != Unit.class) {
+            return null;
+        }
+        try {
+            return UnitResponseBodyConverter.INSTANCE;
+        } catch (NoClassDefFoundError unused) {
+            this.checkForKotlinUnit = false;
+            return null;
+        }
+    }
+}

apk_decompiled/sources/retrofit2/Call.java

@@ -0,0 +1,24 @@
+package retrofit2;
+
+import e3.I;
+import java.io.IOException;
+import r3.K;
+
+/* loaded from: classes3.dex */
+public interface Call<T> extends Cloneable {
+    void cancel();
+
+    Call<T> clone();
+
+    void enqueue(Callback<T> callback);
+
+    Response<T> execute() throws IOException;
+
+    boolean isCanceled();
+
+    boolean isExecuted();
+
+    I request();
+
+    K timeout();
+}

apk_decompiled/sources/retrofit2/CallAdapter.java

@@ -0,0 +1,26 @@
+package retrofit2;
+
+import java.lang.annotation.Annotation;
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Type;
+
+/* loaded from: classes3.dex */
+public interface CallAdapter<R, T> {
+
+    /* loaded from: classes3.dex */
+    public static abstract class Factory {
+        public static Type getParameterUpperBound(int i, ParameterizedType parameterizedType) {
+            return Utils.getParameterUpperBound(i, parameterizedType);
+        }
+
+        public 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();
+}

apk_decompiled/sources/retrofit2/Callback.java

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

apk_decompiled/sources/retrofit2/CompletableFutureCallAdapterFactory.java

@@ -0,0 +1,139 @@
+package retrofit2;
+
+import java.lang.annotation.Annotation;
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Type;
+import java.util.concurrent.CompletableFuture;
+import org.codehaus.mojo.animal_sniffer.IgnoreJRERequirement;
+import retrofit2.CallAdapter;
+
+/* JADX INFO: Access modifiers changed from: package-private */
+@IgnoreJRERequirement
+/* loaded from: classes3.dex */
+public final class CompletableFutureCallAdapterFactory extends CallAdapter.Factory {
+    static final CallAdapter.Factory INSTANCE = new CompletableFutureCallAdapterFactory();
+
+    @IgnoreJRERequirement
+    /* loaded from: classes3.dex */
+    public static final class BodyCallAdapter<R> implements CallAdapter<R, CompletableFuture<R>> {
+        private final Type responseType;
+
+        @IgnoreJRERequirement
+        /* loaded from: classes3.dex */
+        public class BodyCallback implements Callback<R> {
+            private final CompletableFuture<R> future;
+
+            public BodyCallback(CompletableFuture<R> completableFuture) {
+                this.future = completableFuture;
+            }
+
+            @Override // retrofit2.Callback
+            public void onFailure(Call<R> call, Throwable th) {
+                this.future.completeExceptionally(th);
+            }
+
+            @Override // retrofit2.Callback
+            public void onResponse(Call<R> call, Response<R> response) {
+                if (response.isSuccessful()) {
+                    this.future.complete(response.body());
+                } else {
+                    this.future.completeExceptionally(new HttpException(response));
+                }
+            }
+        }
+
+        public BodyCallAdapter(Type type) {
+            this.responseType = type;
+        }
+
+        @Override // retrofit2.CallAdapter
+        public Type responseType() {
+            return this.responseType;
+        }
+
+        @Override // retrofit2.CallAdapter
+        public CompletableFuture<R> adapt(Call<R> call) {
+            CallCancelCompletableFuture callCancelCompletableFuture = new CallCancelCompletableFuture(call);
+            call.enqueue(new BodyCallback(callCancelCompletableFuture));
+            return callCancelCompletableFuture;
+        }
+    }
+
+    @IgnoreJRERequirement
+    /* loaded from: classes3.dex */
+    public static final class CallCancelCompletableFuture<T> extends CompletableFuture<T> {
+        private final Call<?> call;
+
+        public CallCancelCompletableFuture(Call<?> call) {
+            this.call = call;
+        }
+
+        @Override // java.util.concurrent.CompletableFuture, java.util.concurrent.Future
+        public boolean cancel(boolean z3) {
+            if (z3) {
+                this.call.cancel();
+            }
+            return super.cancel(z3);
+        }
+    }
+
+    @IgnoreJRERequirement
+    /* loaded from: classes3.dex */
+    public static final class ResponseCallAdapter<R> implements CallAdapter<R, CompletableFuture<Response<R>>> {
+        private final Type responseType;
+
+        @IgnoreJRERequirement
+        /* loaded from: classes3.dex */
+        public class ResponseCallback implements Callback<R> {
+            private final CompletableFuture<Response<R>> future;
+
+            public ResponseCallback(CompletableFuture<Response<R>> completableFuture) {
+                this.future = completableFuture;
+            }
+
+            @Override // retrofit2.Callback
+            public void onFailure(Call<R> call, Throwable th) {
+                this.future.completeExceptionally(th);
+            }
+
+            @Override // retrofit2.Callback
+            public void onResponse(Call<R> call, Response<R> response) {
+                this.future.complete(response);
+            }
+        }
+
+        public ResponseCallAdapter(Type type) {
+            this.responseType = type;
+        }
+
+        @Override // retrofit2.CallAdapter
+        public Type responseType() {
+            return this.responseType;
+        }
+
+        @Override // retrofit2.CallAdapter
+        public CompletableFuture<Response<R>> adapt(Call<R> call) {
+            CallCancelCompletableFuture callCancelCompletableFuture = new CallCancelCompletableFuture(call);
+            call.enqueue(new ResponseCallback(callCancelCompletableFuture));
+            return callCancelCompletableFuture;
+        }
+    }
+
+    @Override // retrofit2.CallAdapter.Factory
+    public CallAdapter<?, ?> get(Type type, Annotation[] annotationArr, Retrofit retrofit) {
+        if (CallAdapter.Factory.getRawType(type) != CompletableFuture.class) {
+            return null;
+        }
+        if (!(type instanceof ParameterizedType)) {
+            throw new IllegalStateException("CompletableFuture return type must be parameterized as CompletableFuture<Foo> or CompletableFuture<? extends Foo>");
+        }
+        Type parameterUpperBound = CallAdapter.Factory.getParameterUpperBound(0, (ParameterizedType) type);
+        if (CallAdapter.Factory.getRawType(parameterUpperBound) != Response.class) {
+            return new BodyCallAdapter(parameterUpperBound);
+        }
+        if (parameterUpperBound instanceof ParameterizedType) {
+            return new ResponseCallAdapter(CallAdapter.Factory.getParameterUpperBound(0, (ParameterizedType) parameterUpperBound));
+        }
+        throw new IllegalStateException("Response must be parameterized as Response<Foo> or Response<? extends Foo>");
+    }
+}

apk_decompiled/sources/retrofit2/Converter.java

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

apk_decompiled/sources/retrofit2/DefaultCallAdapterFactory.java

@@ -0,0 +1,158 @@
+package retrofit2;
+
+import e3.I;
+import java.io.IOException;
+import java.lang.annotation.Annotation;
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Type;
+import java.util.Objects;
+import java.util.concurrent.Executor;
+import r3.K;
+import retrofit2.CallAdapter;
+
+/* JADX INFO: Access modifiers changed from: package-private */
+/* loaded from: classes3.dex */
+public final class DefaultCallAdapterFactory extends CallAdapter.Factory {
+    private final Executor callbackExecutor;
+
+    /* renamed from: retrofit2.DefaultCallAdapterFactory$1 */
+    /* loaded from: classes3.dex */
+    public class AnonymousClass1 implements CallAdapter<Object, Call<?>> {
+        final /* synthetic */ Executor val$executor;
+        final /* synthetic */ Type val$responseType;
+
+        public AnonymousClass1(Type type, Executor executor) {
+            r2 = type;
+            r3 = executor;
+        }
+
+        @Override // retrofit2.CallAdapter
+        public Type responseType() {
+            return r2;
+        }
+
+        @Override // retrofit2.CallAdapter
+        public Call<?> adapt(Call<Object> call) {
+            Executor executor = r3;
+            return executor == null ? call : new ExecutorCallbackCall(executor, call);
+        }
+    }
+
+    /* loaded from: classes3.dex */
+    public static final class ExecutorCallbackCall<T> implements Call<T> {
+        final Executor callbackExecutor;
+        final Call<T> delegate;
+
+        /* renamed from: retrofit2.DefaultCallAdapterFactory$ExecutorCallbackCall$1 */
+        /* loaded from: classes3.dex */
+        public class AnonymousClass1 implements Callback<T> {
+            final /* synthetic */ Callback val$callback;
+
+            public AnonymousClass1(Callback callback) {
+                this.val$callback = callback;
+            }
+
+            public /* synthetic */ void lambda$onFailure$1(Callback callback, Throwable th) {
+                callback.onFailure(ExecutorCallbackCall.this, th);
+            }
+
+            public /* synthetic */ void lambda$onResponse$0(Callback callback, Response response) {
+                if (ExecutorCallbackCall.this.delegate.isCanceled()) {
+                    callback.onFailure(ExecutorCallbackCall.this, new IOException("Canceled"));
+                } else {
+                    callback.onResponse(ExecutorCallbackCall.this, response);
+                }
+            }
+
+            @Override // retrofit2.Callback
+            public void onFailure(Call<T> call, Throwable th) {
+                ExecutorCallbackCall.this.callbackExecutor.execute(new a(this, this.val$callback, th, 1));
+            }
+
+            @Override // retrofit2.Callback
+            public void onResponse(Call<T> call, Response<T> response) {
+                ExecutorCallbackCall.this.callbackExecutor.execute(new a(this, this.val$callback, response, 0));
+            }
+        }
+
+        public 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(Callback<T> callback) {
+            Objects.requireNonNull(callback, "callback == null");
+            this.delegate.enqueue(new AnonymousClass1(callback));
+        }
+
+        @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 I request() {
+            return this.delegate.request();
+        }
+
+        @Override // retrofit2.Call
+        public K timeout() {
+            return this.delegate.timeout();
+        }
+
+        @Override // retrofit2.Call
+        public Call<T> clone() {
+            return new ExecutorCallbackCall(this.callbackExecutor, this.delegate.clone());
+        }
+    }
+
+    public DefaultCallAdapterFactory(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;
+        }
+        if (type instanceof ParameterizedType) {
+            return new CallAdapter<Object, Call<?>>() { // from class: retrofit2.DefaultCallAdapterFactory.1
+                final /* synthetic */ Executor val$executor;
+                final /* synthetic */ Type val$responseType;
+
+                public AnonymousClass1(Type type2, Executor executor) {
+                    r2 = type2;
+                    r3 = executor;
+                }
+
+                @Override // retrofit2.CallAdapter
+                public Type responseType() {
+                    return r2;
+                }
+
+                @Override // retrofit2.CallAdapter
+                public Call<?> adapt(Call<Object> call) {
+                    Executor executor = r3;
+                    return executor == null ? call : new ExecutorCallbackCall(executor, call);
+                }
+            };
+        }
+        throw new IllegalArgumentException("Call return type must be parameterized as Call<Foo> or Call<? extends Foo>");
+    }
+}

apk_decompiled/sources/retrofit2/HttpException.java

@@ -0,0 +1,34 @@
+package retrofit2;
+
+import java.util.Objects;
+
+/* loaded from: classes3.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) {
+        Objects.requireNonNull(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;
+    }
+}

apk_decompiled/sources/retrofit2/HttpServiceMethod.java

@@ -0,0 +1,143 @@
+package retrofit2;
+
+import e3.InterfaceC0318d;
+import e3.O;
+import e3.T;
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Method;
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Type;
+import kotlin.coroutines.Continuation;
+import retrofit2.Utils;
+
+/* JADX INFO: Access modifiers changed from: package-private */
+/* loaded from: classes3.dex */
+public abstract class HttpServiceMethod<ResponseT, ReturnT> extends ServiceMethod<ReturnT> {
+    private final InterfaceC0318d callFactory;
+    private final RequestFactory requestFactory;
+    private final Converter<T, ResponseT> responseConverter;
+
+    /* loaded from: classes3.dex */
+    public static final class CallAdapted<ResponseT, ReturnT> extends HttpServiceMethod<ResponseT, ReturnT> {
+        private final CallAdapter<ResponseT, ReturnT> callAdapter;
+
+        public CallAdapted(RequestFactory requestFactory, InterfaceC0318d interfaceC0318d, Converter<T, ResponseT> converter, CallAdapter<ResponseT, ReturnT> callAdapter) {
+            super(requestFactory, interfaceC0318d, converter);
+            this.callAdapter = callAdapter;
+        }
+
+        @Override // retrofit2.HttpServiceMethod
+        public ReturnT adapt(Call<ResponseT> call, Object[] objArr) {
+            return this.callAdapter.adapt(call);
+        }
+    }
+
+    /* loaded from: classes3.dex */
+    public static final class SuspendForBody<ResponseT> extends HttpServiceMethod<ResponseT, Object> {
+        private final CallAdapter<ResponseT, Call<ResponseT>> callAdapter;
+        private final boolean isNullable;
+
+        public SuspendForBody(RequestFactory requestFactory, InterfaceC0318d interfaceC0318d, Converter<T, ResponseT> converter, CallAdapter<ResponseT, Call<ResponseT>> callAdapter, boolean z3) {
+            super(requestFactory, interfaceC0318d, converter);
+            this.callAdapter = callAdapter;
+            this.isNullable = z3;
+        }
+
+        @Override // retrofit2.HttpServiceMethod
+        public Object adapt(Call<ResponseT> call, Object[] objArr) {
+            Call<ResponseT> adapt = this.callAdapter.adapt(call);
+            Continuation continuation = (Continuation) objArr[objArr.length - 1];
+            try {
+                return this.isNullable ? KotlinExtensions.awaitNullable(adapt, continuation) : KotlinExtensions.await(adapt, continuation);
+            } catch (Exception e4) {
+                return KotlinExtensions.suspendAndThrow(e4, continuation);
+            }
+        }
+    }
+
+    /* loaded from: classes3.dex */
+    public static final class SuspendForResponse<ResponseT> extends HttpServiceMethod<ResponseT, Object> {
+        private final CallAdapter<ResponseT, Call<ResponseT>> callAdapter;
+
+        public SuspendForResponse(RequestFactory requestFactory, InterfaceC0318d interfaceC0318d, Converter<T, ResponseT> converter, CallAdapter<ResponseT, Call<ResponseT>> callAdapter) {
+            super(requestFactory, interfaceC0318d, converter);
+            this.callAdapter = callAdapter;
+        }
+
+        @Override // retrofit2.HttpServiceMethod
+        public Object adapt(Call<ResponseT> call, Object[] objArr) {
+            Call<ResponseT> adapt = this.callAdapter.adapt(call);
+            Continuation continuation = (Continuation) objArr[objArr.length - 1];
+            try {
+                return KotlinExtensions.awaitResponse(adapt, continuation);
+            } catch (Exception e4) {
+                return KotlinExtensions.suspendAndThrow(e4, continuation);
+            }
+        }
+    }
+
+    public HttpServiceMethod(RequestFactory requestFactory, InterfaceC0318d interfaceC0318d, Converter<T, ResponseT> converter) {
+        this.requestFactory = requestFactory;
+        this.callFactory = interfaceC0318d;
+        this.responseConverter = converter;
+    }
+
+    private static <ResponseT, ReturnT> CallAdapter<ResponseT, ReturnT> createCallAdapter(Retrofit retrofit, Method method, Type type, Annotation[] annotationArr) {
+        try {
+            return (CallAdapter<ResponseT, ReturnT>) retrofit.callAdapter(type, annotationArr);
+        } catch (RuntimeException e4) {
+            throw Utils.methodError(method, e4, "Unable to create call adapter for %s", type);
+        }
+    }
+
+    private static <ResponseT> Converter<T, ResponseT> createResponseConverter(Retrofit retrofit, Method method, Type type) {
+        try {
+            return retrofit.responseBodyConverter(type, method.getAnnotations());
+        } catch (RuntimeException e4) {
+            throw Utils.methodError(method, e4, "Unable to create converter for %s", type);
+        }
+    }
+
+    public static <ResponseT, ReturnT> HttpServiceMethod<ResponseT, ReturnT> parseAnnotations(Retrofit retrofit, Method method, RequestFactory requestFactory) {
+        Type genericReturnType;
+        boolean z3;
+        boolean z4 = requestFactory.isKotlinSuspendFunction;
+        Annotation[] annotations = method.getAnnotations();
+        if (z4) {
+            Type[] genericParameterTypes = method.getGenericParameterTypes();
+            Type parameterLowerBound = Utils.getParameterLowerBound(0, (ParameterizedType) genericParameterTypes[genericParameterTypes.length - 1]);
+            if (Utils.getRawType(parameterLowerBound) == Response.class && (parameterLowerBound instanceof ParameterizedType)) {
+                parameterLowerBound = Utils.getParameterUpperBound(0, (ParameterizedType) parameterLowerBound);
+                z3 = true;
+            } else {
+                z3 = false;
+            }
+            genericReturnType = new Utils.ParameterizedTypeImpl(null, Call.class, parameterLowerBound);
+            annotations = SkipCallbackExecutorImpl.ensurePresent(annotations);
+        } else {
+            genericReturnType = method.getGenericReturnType();
+            z3 = false;
+        }
+        CallAdapter createCallAdapter = createCallAdapter(retrofit, method, genericReturnType, annotations);
+        Type responseType = createCallAdapter.responseType();
+        if (responseType == O.class) {
+            throw Utils.methodError(method, "'" + Utils.getRawType(responseType).getName() + "' is not a valid response body type. Did you mean ResponseBody?", new Object[0]);
+        }
+        if (responseType == Response.class) {
+            throw Utils.methodError(method, "Response must include generic type (e.g., Response<String>)", new Object[0]);
+        }
+        if (requestFactory.httpMethod.equals("HEAD") && !Void.class.equals(responseType)) {
+            throw Utils.methodError(method, "HEAD method must use Void as response type.", new Object[0]);
+        }
+        Converter createResponseConverter = createResponseConverter(retrofit, method, responseType);
+        InterfaceC0318d interfaceC0318d = retrofit.callFactory;
+        return !z4 ? new CallAdapted(requestFactory, interfaceC0318d, createResponseConverter, createCallAdapter) : z3 ? new SuspendForResponse(requestFactory, interfaceC0318d, createResponseConverter, createCallAdapter) : new SuspendForBody(requestFactory, interfaceC0318d, createResponseConverter, createCallAdapter, false);
+    }
+
+    public abstract ReturnT adapt(Call<ResponseT> call, Object[] objArr);
+
+    @Override // retrofit2.ServiceMethod
+    public final ReturnT invoke(Object[] objArr) {
+        return adapt(new OkHttpCall(this.requestFactory, objArr, this.callFactory, this.responseConverter), objArr);
+    }
+}

apk_decompiled/sources/retrofit2/Invocation.java

@@ -0,0 +1,36 @@
+package retrofit2;
+
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Objects;
+
+/* loaded from: classes3.dex */
+public final class Invocation {
+    private final List<?> arguments;
+    private final Method method;
+
+    public Invocation(Method method, List<?> list) {
+        this.method = method;
+        this.arguments = Collections.unmodifiableList(list);
+    }
+
+    public static Invocation of(Method method, List<?> list) {
+        Objects.requireNonNull(method, "method == null");
+        Objects.requireNonNull(list, "arguments == null");
+        return new Invocation(method, new ArrayList(list));
+    }
+
+    public List<?> arguments() {
+        return this.arguments;
+    }
+
+    public Method method() {
+        return this.method;
+    }
+
+    public String toString() {
+        return String.format("%s.%s() %s", this.method.getDeclaringClass().getName(), this.method.getName(), this.arguments);
+    }
+}

apk_decompiled/sources/retrofit2/KotlinExtensions$suspendAndThrow$1.java

@@ -0,0 +1,27 @@
+package retrofit2;
+
+import kotlin.Metadata;
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.jvm.internal.ContinuationImpl;
+import kotlin.coroutines.jvm.internal.DebugMetadata;
+import kotlin.jvm.internal.IntCompanionObject;
+
+@Metadata(bv = {1, 0, 3}, d1 = {"\u0000\u0018\n\u0000\n\u0002\u0010\u0000\n\u0002\u0018\u0002\n\u0002\u0018\u0002\n\u0000\n\u0002\u0018\u0002\n\u0002\u0010\u0001\u0010\u0000\u001a\u0004\u0018\u00010\u0001*\u00060\u0002j\u0002`\u00032\f\u0010\u0004\u001a\b\u0012\u0004\u0012\u00020\u00060\u0005H\u0080@"}, d2 = {"suspendAndThrow", "", "Ljava/lang/Exception;", "Lkotlin/Exception;", "continuation", "Lkotlin/coroutines/Continuation;", ""}, k = 3, mv = {1, 1, 15})
+@DebugMetadata(c = "retrofit2.KotlinExtensions", f = "KotlinExtensions.kt", i = {0}, l = {113}, m = "suspendAndThrow", n = {"$this$suspendAndThrow"}, s = {"L$0"})
+/* loaded from: classes3.dex */
+public final class KotlinExtensions$suspendAndThrow$1 extends ContinuationImpl {
+    Object L$0;
+    int label;
+    /* synthetic */ Object result;
+
+    public KotlinExtensions$suspendAndThrow$1(Continuation continuation) {
+        super(continuation);
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Object invokeSuspend(Object obj) {
+        this.result = obj;
+        this.label |= IntCompanionObject.MIN_VALUE;
+        return KotlinExtensions.suspendAndThrow(null, this);
+    }
+}

apk_decompiled/sources/retrofit2/KotlinExtensions.java

@@ -0,0 +1,255 @@
+package retrofit2;
+
+import e3.I;
+import java.lang.reflect.Method;
+import kotlin.KotlinNullPointerException;
+import kotlin.Metadata;
+import kotlin.Result;
+import kotlin.ResultKt;
+import kotlin.Unit;
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.intrinsics.IntrinsicsKt;
+import kotlin.coroutines.jvm.internal.DebugProbesKt;
+import kotlin.jvm.JvmName;
+import kotlin.jvm.functions.Function1;
+import kotlin.jvm.internal.Intrinsics;
+import kotlinx.coroutines.CancellableContinuation;
+import kotlinx.coroutines.CancellableContinuationImpl;
+
+@Metadata(bv = {1, 0, 3}, d1 = {"\u0000.\n\u0002\b\u0002\n\u0002\u0010\u0000\n\u0002\u0018\u0002\n\u0002\b\u0003\n\u0002\u0018\u0002\n\u0000\n\u0002\u0018\u0002\n\u0002\b\u0002\n\u0002\u0010\u0001\n\u0002\u0018\u0002\n\u0002\u0018\u0002\n\u0002\b\u0002\u001a%\u0010\u0000\u001a\u0002H\u0001\"\b\b\u0000\u0010\u0001*\u00020\u0002*\b\u0012\u0004\u0012\u0002H\u00010\u0003H\u0086@ø\u0001\u0000¢\u0006\u0002\u0010\u0004\u001a+\u0010\u0000\u001a\u0004\u0018\u0001H\u0001\"\b\b\u0000\u0010\u0001*\u00020\u0002*\n\u0012\u0006\u0012\u0004\u0018\u0001H\u00010\u0003H\u0087@ø\u0001\u0000¢\u0006\u0004\b\u0005\u0010\u0004\u001a'\u0010\u0006\u001a\b\u0012\u0004\u0012\u0002H\u00010\u0007\"\u0004\b\u0000\u0010\u0001*\b\u0012\u0004\u0012\u0002H\u00010\u0003H\u0086@ø\u0001\u0000¢\u0006\u0002\u0010\u0004\u001a\u001a\u0010\b\u001a\u0002H\u0001\"\u0006\b\u0000\u0010\u0001\u0018\u0001*\u00020\tH\u0086\b¢\u0006\u0002\u0010\n\u001a\u0019\u0010\u000b\u001a\u00020\f*\u00060\rj\u0002`\u000eH\u0080@ø\u0001\u0000¢\u0006\u0002\u0010\u000f\u0082\u0002\u0004\n\u0002\b\u0019¨\u0006\u0010"}, d2 = {"await", "T", "", "Lretrofit2/Call;", "(Lretrofit2/Call;Lkotlin/coroutines/Continuation;)Ljava/lang/Object;", "awaitNullable", "awaitResponse", "Lretrofit2/Response;", "create", "Lretrofit2/Retrofit;", "(Lretrofit2/Retrofit;)Ljava/lang/Object;", "suspendAndThrow", "", "Ljava/lang/Exception;", "Lkotlin/Exception;", "(Ljava/lang/Exception;Lkotlin/coroutines/Continuation;)Ljava/lang/Object;", "retrofit"}, k = 2, mv = {1, 1, 15})
+@JvmName(name = "KotlinExtensions")
+/* loaded from: classes3.dex */
+public final class KotlinExtensions {
+    public static final <T> Object await(final Call<T> call, Continuation<? super T> continuation) {
+        final CancellableContinuationImpl cancellableContinuationImpl = new CancellableContinuationImpl(IntrinsicsKt.intercepted(continuation), 1);
+        cancellableContinuationImpl.invokeOnCancellation(new Function1<Throwable, Unit>() { // from class: retrofit2.KotlinExtensions$await$$inlined$suspendCancellableCoroutine$lambda$1
+            {
+                super(1);
+            }
+
+            @Override // kotlin.jvm.functions.Function1
+            public /* bridge */ /* synthetic */ Unit invoke(Throwable th) {
+                invoke2(th);
+                return Unit.INSTANCE;
+            }
+
+            /* renamed from: invoke, reason: avoid collision after fix types in other method */
+            public final void invoke2(Throwable th) {
+                Call.this.cancel();
+            }
+        });
+        call.enqueue(new Callback<T>() { // from class: retrofit2.KotlinExtensions$await$2$2
+            @Override // retrofit2.Callback
+            public void onFailure(Call<T> call2, Throwable t2) {
+                Intrinsics.checkParameterIsNotNull(call2, "call");
+                Intrinsics.checkParameterIsNotNull(t2, "t");
+                CancellableContinuation cancellableContinuation = CancellableContinuation.this;
+                Result.Companion companion = Result.INSTANCE;
+                cancellableContinuation.resumeWith(Result.m116constructorimpl(ResultKt.createFailure(t2)));
+            }
+
+            @Override // retrofit2.Callback
+            public void onResponse(Call<T> call2, Response<T> response) {
+                Intrinsics.checkParameterIsNotNull(call2, "call");
+                Intrinsics.checkParameterIsNotNull(response, "response");
+                if (!response.isSuccessful()) {
+                    CancellableContinuation cancellableContinuation = CancellableContinuation.this;
+                    HttpException httpException = new HttpException(response);
+                    Result.Companion companion = Result.INSTANCE;
+                    cancellableContinuation.resumeWith(Result.m116constructorimpl(ResultKt.createFailure(httpException)));
+                    return;
+                }
+                T body = response.body();
+                if (body != null) {
+                    CancellableContinuation.this.resumeWith(Result.m116constructorimpl(body));
+                    return;
+                }
+                I request = call2.request();
+                request.getClass();
+                Intrinsics.checkNotNullParameter(Invocation.class, "type");
+                Object cast = Invocation.class.cast(request.f6271e.get(Invocation.class));
+                if (cast == null) {
+                    Intrinsics.throwNpe();
+                }
+                Intrinsics.checkExpressionValueIsNotNull(cast, "call.request().tag(Invocation::class.java)!!");
+                Method method = ((Invocation) cast).method();
+                StringBuilder sb = new StringBuilder("Response from ");
+                Intrinsics.checkExpressionValueIsNotNull(method, "method");
+                Class<?> declaringClass = method.getDeclaringClass();
+                Intrinsics.checkExpressionValueIsNotNull(declaringClass, "method.declaringClass");
+                sb.append(declaringClass.getName());
+                sb.append('.');
+                sb.append(method.getName());
+                sb.append(" was null but response body type was declared as non-null");
+                KotlinNullPointerException kotlinNullPointerException = new KotlinNullPointerException(sb.toString());
+                CancellableContinuation cancellableContinuation2 = CancellableContinuation.this;
+                Result.Companion companion2 = Result.INSTANCE;
+                cancellableContinuation2.resumeWith(Result.m116constructorimpl(ResultKt.createFailure(kotlinNullPointerException)));
+            }
+        });
+        Object result = cancellableContinuationImpl.getResult();
+        if (result == IntrinsicsKt.getCOROUTINE_SUSPENDED()) {
+            DebugProbesKt.probeCoroutineSuspended(continuation);
+        }
+        return result;
+    }
+
+    @JvmName(name = "awaitNullable")
+    public static final <T> Object awaitNullable(final Call<T> call, Continuation<? super T> continuation) {
+        final CancellableContinuationImpl cancellableContinuationImpl = new CancellableContinuationImpl(IntrinsicsKt.intercepted(continuation), 1);
+        cancellableContinuationImpl.invokeOnCancellation(new Function1<Throwable, Unit>() { // from class: retrofit2.KotlinExtensions$await$$inlined$suspendCancellableCoroutine$lambda$2
+            {
+                super(1);
+            }
+
+            @Override // kotlin.jvm.functions.Function1
+            public /* bridge */ /* synthetic */ Unit invoke(Throwable th) {
+                invoke2(th);
+                return Unit.INSTANCE;
+            }
+
+            /* renamed from: invoke, reason: avoid collision after fix types in other method */
+            public final void invoke2(Throwable th) {
+                Call.this.cancel();
+            }
+        });
+        call.enqueue(new Callback<T>() { // from class: retrofit2.KotlinExtensions$await$4$2
+            @Override // retrofit2.Callback
+            public void onFailure(Call<T> call2, Throwable t2) {
+                Intrinsics.checkParameterIsNotNull(call2, "call");
+                Intrinsics.checkParameterIsNotNull(t2, "t");
+                CancellableContinuation cancellableContinuation = CancellableContinuation.this;
+                Result.Companion companion = Result.INSTANCE;
+                cancellableContinuation.resumeWith(Result.m116constructorimpl(ResultKt.createFailure(t2)));
+            }
+
+            @Override // retrofit2.Callback
+            public void onResponse(Call<T> call2, Response<T> response) {
+                Intrinsics.checkParameterIsNotNull(call2, "call");
+                Intrinsics.checkParameterIsNotNull(response, "response");
+                if (response.isSuccessful()) {
+                    CancellableContinuation.this.resumeWith(Result.m116constructorimpl(response.body()));
+                    return;
+                }
+                CancellableContinuation cancellableContinuation = CancellableContinuation.this;
+                HttpException httpException = new HttpException(response);
+                Result.Companion companion = Result.INSTANCE;
+                cancellableContinuation.resumeWith(Result.m116constructorimpl(ResultKt.createFailure(httpException)));
+            }
+        });
+        Object result = cancellableContinuationImpl.getResult();
+        if (result == IntrinsicsKt.getCOROUTINE_SUSPENDED()) {
+            DebugProbesKt.probeCoroutineSuspended(continuation);
+        }
+        return result;
+    }
+
+    public static final <T> Object awaitResponse(final Call<T> call, Continuation<? super Response<T>> continuation) {
+        final CancellableContinuationImpl cancellableContinuationImpl = new CancellableContinuationImpl(IntrinsicsKt.intercepted(continuation), 1);
+        cancellableContinuationImpl.invokeOnCancellation(new Function1<Throwable, Unit>() { // from class: retrofit2.KotlinExtensions$awaitResponse$$inlined$suspendCancellableCoroutine$lambda$1
+            {
+                super(1);
+            }
+
+            @Override // kotlin.jvm.functions.Function1
+            public /* bridge */ /* synthetic */ Unit invoke(Throwable th) {
+                invoke2(th);
+                return Unit.INSTANCE;
+            }
+
+            /* renamed from: invoke, reason: avoid collision after fix types in other method */
+            public final void invoke2(Throwable th) {
+                Call.this.cancel();
+            }
+        });
+        call.enqueue(new Callback<T>() { // from class: retrofit2.KotlinExtensions$awaitResponse$2$2
+            @Override // retrofit2.Callback
+            public void onFailure(Call<T> call2, Throwable t2) {
+                Intrinsics.checkParameterIsNotNull(call2, "call");
+                Intrinsics.checkParameterIsNotNull(t2, "t");
+                CancellableContinuation cancellableContinuation = CancellableContinuation.this;
+                Result.Companion companion = Result.INSTANCE;
+                cancellableContinuation.resumeWith(Result.m116constructorimpl(ResultKt.createFailure(t2)));
+            }
+
+            @Override // retrofit2.Callback
+            public void onResponse(Call<T> call2, Response<T> response) {
+                Intrinsics.checkParameterIsNotNull(call2, "call");
+                Intrinsics.checkParameterIsNotNull(response, "response");
+                CancellableContinuation.this.resumeWith(Result.m116constructorimpl(response));
+            }
+        });
+        Object result = cancellableContinuationImpl.getResult();
+        if (result == IntrinsicsKt.getCOROUTINE_SUSPENDED()) {
+            DebugProbesKt.probeCoroutineSuspended(continuation);
+        }
+        return result;
+    }
+
+    public static final /* synthetic */ <T> T create(Retrofit create) {
+        Intrinsics.checkParameterIsNotNull(create, "$this$create");
+        Intrinsics.reifiedOperationMarker(4, "T");
+        return (T) create.create(Object.class);
+    }
+
+    /* JADX WARN: Removed duplicated region for block: B:15:0x0035  */
+    /* JADX WARN: Removed duplicated region for block: B:8:0x0023  */
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    public static final java.lang.Object suspendAndThrow(final java.lang.Exception r4, kotlin.coroutines.Continuation<?> r5) {
+        /*
+            boolean r0 = r5 instanceof retrofit2.KotlinExtensions$suspendAndThrow$1
+            if (r0 == 0) goto L13
+            r0 = r5
+            retrofit2.KotlinExtensions$suspendAndThrow$1 r0 = (retrofit2.KotlinExtensions$suspendAndThrow$1) r0
+            int r1 = r0.label
+            r2 = -2147483648(0xffffffff80000000, float:-0.0)
+            r3 = r1 & r2
+            if (r3 == 0) goto L13
+            int r1 = r1 - r2
+            r0.label = r1
+            goto L18
+        L13:
+            retrofit2.KotlinExtensions$suspendAndThrow$1 r0 = new retrofit2.KotlinExtensions$suspendAndThrow$1
+            r0.<init>(r5)
+        L18:
+            java.lang.Object r5 = r0.result
+            java.lang.Object r1 = kotlin.coroutines.intrinsics.IntrinsicsKt.getCOROUTINE_SUSPENDED()
+            int r2 = r0.label
+            r3 = 1
+            if (r2 == 0) goto L35
+            if (r2 != r3) goto L2d
+            java.lang.Object r4 = r0.L$0
+            java.lang.Exception r4 = (java.lang.Exception) r4
+            kotlin.ResultKt.throwOnFailure(r5)
+            goto L5c
+        L2d:
+            java.lang.IllegalStateException r4 = new java.lang.IllegalStateException
+            java.lang.String r5 = "call to 'resume' before 'invoke' with coroutine"
+            r4.<init>(r5)
+            throw r4
+        L35:
+            kotlin.ResultKt.throwOnFailure(r5)
+            r0.L$0 = r4
+            r0.label = r3
+            kotlinx.coroutines.CoroutineDispatcher r5 = kotlinx.coroutines.Dispatchers.getDefault()
+            kotlin.coroutines.CoroutineContext r2 = r0.get$context()
+            retrofit2.KotlinExtensions$suspendAndThrow$$inlined$suspendCoroutineUninterceptedOrReturn$lambda$1 r3 = new retrofit2.KotlinExtensions$suspendAndThrow$$inlined$suspendCoroutineUninterceptedOrReturn$lambda$1
+            r3.<init>()
+            r5.mo1685dispatch(r2, r3)
+            java.lang.Object r4 = kotlin.coroutines.intrinsics.IntrinsicsKt.getCOROUTINE_SUSPENDED()
+            java.lang.Object r5 = kotlin.coroutines.intrinsics.IntrinsicsKt.getCOROUTINE_SUSPENDED()
+            if (r4 != r5) goto L59
+            kotlin.coroutines.jvm.internal.DebugProbesKt.probeCoroutineSuspended(r0)
+        L59:
+            if (r4 != r1) goto L5c
+            return r1
+        L5c:
+            kotlin.Unit r4 = kotlin.Unit.INSTANCE
+            return r4
+        */
+        throw new UnsupportedOperationException("Method not decompiled: retrofit2.KotlinExtensions.suspendAndThrow(java.lang.Exception, kotlin.coroutines.Continuation):java.lang.Object");
+    }
+}

apk_decompiled/sources/retrofit2/OkHttpCall.java

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

apk_decompiled/sources/retrofit2/OptionalConverterFactory.java

@@ -0,0 +1,40 @@
+package retrofit2;
+
+import e3.T;
+import java.io.IOException;
+import java.lang.annotation.Annotation;
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Type;
+import java.util.Optional;
+import org.codehaus.mojo.animal_sniffer.IgnoreJRERequirement;
+import retrofit2.Converter;
+
+/* JADX INFO: Access modifiers changed from: package-private */
+@IgnoreJRERequirement
+/* loaded from: classes3.dex */
+public final class OptionalConverterFactory extends Converter.Factory {
+    static final Converter.Factory INSTANCE = new OptionalConverterFactory();
+
+    @IgnoreJRERequirement
+    /* loaded from: classes3.dex */
+    public static final class OptionalConverter<T> implements Converter<T, Optional<T>> {
+        final Converter<T, T> delegate;
+
+        public OptionalConverter(Converter<T, T> converter) {
+            this.delegate = converter;
+        }
+
+        @Override // retrofit2.Converter
+        public Optional<T> convert(T t2) throws IOException {
+            return Optional.ofNullable(this.delegate.convert(t2));
+        }
+    }
+
+    @Override // retrofit2.Converter.Factory
+    public Converter<T, ?> responseBodyConverter(Type type, Annotation[] annotationArr, Retrofit retrofit) {
+        if (Converter.Factory.getRawType(type) != Optional.class) {
+            return null;
+        }
+        return new OptionalConverter(retrofit.responseBodyConverter(Converter.Factory.getParameterUpperBound(0, (ParameterizedType) type), annotationArr));
+    }
+}

apk_decompiled/sources/retrofit2/ParameterHandler.java

@@ -0,0 +1,435 @@
+package retrofit2;
+
+import C.w;
+import a.AbstractC0105a;
+import e3.C;
+import e3.C0334u;
+import e3.M;
+import java.io.IOException;
+import java.lang.reflect.Array;
+import java.lang.reflect.Method;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Objects;
+
+/* JADX INFO: Access modifiers changed from: package-private */
+/* loaded from: classes3.dex */
+public abstract class ParameterHandler<T> {
+
+    /* loaded from: classes3.dex */
+    public static final class Body<T> extends ParameterHandler<T> {
+        private final Converter<T, M> converter;
+        private final Method method;
+        private final int p;
+
+        public Body(Method method, int i, Converter<T, M> converter) {
+            this.method = method;
+            this.p = i;
+            this.converter = converter;
+        }
+
+        @Override // retrofit2.ParameterHandler
+        public void apply(RequestBuilder requestBuilder, T t2) {
+            if (t2 == null) {
+                throw Utils.parameterError(this.method, this.p, "Body parameter value must not be null.", new Object[0]);
+            }
+            try {
+                requestBuilder.setBody(this.converter.convert(t2));
+            } catch (IOException e4) {
+                throw Utils.parameterError(this.method, e4, this.p, "Unable to convert " + t2 + " to RequestBody", new Object[0]);
+            }
+        }
+    }
+
+    /* loaded from: classes3.dex */
+    public static final class Field<T> extends ParameterHandler<T> {
+        private final boolean encoded;
+        private final String name;
+        private final Converter<T, String> valueConverter;
+
+        public Field(String str, Converter<T, String> converter, boolean z3) {
+            Objects.requireNonNull(str, "name == null");
+            this.name = str;
+            this.valueConverter = converter;
+            this.encoded = z3;
+        }
+
+        @Override // retrofit2.ParameterHandler
+        public void apply(RequestBuilder requestBuilder, T t2) throws IOException {
+            String convert;
+            if (t2 == null || (convert = this.valueConverter.convert(t2)) == null) {
+                return;
+            }
+            requestBuilder.addFormField(this.name, convert, this.encoded);
+        }
+    }
+
+    /* loaded from: classes3.dex */
+    public static final class FieldMap<T> extends ParameterHandler<Map<String, T>> {
+        private final boolean encoded;
+        private final Method method;
+        private final int p;
+        private final Converter<T, String> valueConverter;
+
+        public FieldMap(Method method, int i, Converter<T, String> converter, boolean z3) {
+            this.method = method;
+            this.p = i;
+            this.valueConverter = converter;
+            this.encoded = z3;
+        }
+
+        @Override // retrofit2.ParameterHandler
+        public void apply(RequestBuilder requestBuilder, Map<String, T> map) throws IOException {
+            if (map != null) {
+                for (Map.Entry<String, T> entry : map.entrySet()) {
+                    String key = entry.getKey();
+                    if (key != null) {
+                        T value = entry.getValue();
+                        if (value != null) {
+                            String convert = this.valueConverter.convert(value);
+                            if (convert != null) {
+                                requestBuilder.addFormField(key, convert, this.encoded);
+                            } else {
+                                throw Utils.parameterError(this.method, this.p, "Field map value '" + value + "' converted to null by " + this.valueConverter.getClass().getName() + " for key '" + key + "'.", new Object[0]);
+                            }
+                        } else {
+                            throw Utils.parameterError(this.method, this.p, w.o("Field map contained null value for key '", key, "'."), new Object[0]);
+                        }
+                    } else {
+                        throw Utils.parameterError(this.method, this.p, "Field map contained null key.", new Object[0]);
+                    }
+                }
+                return;
+            }
+            throw Utils.parameterError(this.method, this.p, "Field map was null.", new Object[0]);
+        }
+    }
+
+    /* loaded from: classes3.dex */
+    public static final class Header<T> extends ParameterHandler<T> {
+        private final String name;
+        private final Converter<T, String> valueConverter;
+
+        public Header(String str, Converter<T, String> converter) {
+            Objects.requireNonNull(str, "name == null");
+            this.name = str;
+            this.valueConverter = converter;
+        }
+
+        @Override // retrofit2.ParameterHandler
+        public void apply(RequestBuilder requestBuilder, T t2) throws IOException {
+            String convert;
+            if (t2 == null || (convert = this.valueConverter.convert(t2)) == null) {
+                return;
+            }
+            requestBuilder.addHeader(this.name, convert);
+        }
+    }
+
+    /* loaded from: classes3.dex */
+    public static final class HeaderMap<T> extends ParameterHandler<Map<String, T>> {
+        private final Method method;
+        private final int p;
+        private final Converter<T, String> valueConverter;
+
+        public HeaderMap(Method method, int i, Converter<T, String> converter) {
+            this.method = method;
+            this.p = i;
+            this.valueConverter = converter;
+        }
+
+        @Override // retrofit2.ParameterHandler
+        public void apply(RequestBuilder requestBuilder, Map<String, T> map) throws IOException {
+            if (map != null) {
+                for (Map.Entry<String, T> entry : map.entrySet()) {
+                    String key = entry.getKey();
+                    if (key != null) {
+                        T value = entry.getValue();
+                        if (value != null) {
+                            requestBuilder.addHeader(key, this.valueConverter.convert(value));
+                        } else {
+                            throw Utils.parameterError(this.method, this.p, w.o("Header map contained null value for key '", key, "'."), new Object[0]);
+                        }
+                    } else {
+                        throw Utils.parameterError(this.method, this.p, "Header map contained null key.", new Object[0]);
+                    }
+                }
+                return;
+            }
+            throw Utils.parameterError(this.method, this.p, "Header map was null.", new Object[0]);
+        }
+    }
+
+    /* loaded from: classes3.dex */
+    public static final class Headers extends ParameterHandler<C0334u> {
+        private final Method method;
+        private final int p;
+
+        public Headers(Method method, int i) {
+            this.method = method;
+            this.p = i;
+        }
+
+        @Override // retrofit2.ParameterHandler
+        public void apply(RequestBuilder requestBuilder, C0334u c0334u) {
+            if (c0334u != null) {
+                requestBuilder.addHeaders(c0334u);
+                return;
+            }
+            throw Utils.parameterError(this.method, this.p, "Headers parameter must not be null.", new Object[0]);
+        }
+    }
+
+    /* loaded from: classes3.dex */
+    public static final class Part<T> extends ParameterHandler<T> {
+        private final Converter<T, M> converter;
+        private final C0334u headers;
+        private final Method method;
+        private final int p;
+
+        public Part(Method method, int i, C0334u c0334u, Converter<T, M> converter) {
+            this.method = method;
+            this.p = i;
+            this.headers = c0334u;
+            this.converter = converter;
+        }
+
+        @Override // retrofit2.ParameterHandler
+        public void apply(RequestBuilder requestBuilder, T t2) {
+            if (t2 == null) {
+                return;
+            }
+            try {
+                requestBuilder.addPart(this.headers, this.converter.convert(t2));
+            } catch (IOException e4) {
+                throw Utils.parameterError(this.method, this.p, "Unable to convert " + t2 + " to RequestBody", e4);
+            }
+        }
+    }
+
+    /* loaded from: classes3.dex */
+    public static final class PartMap<T> extends ParameterHandler<Map<String, T>> {
+        private final Method method;
+        private final int p;
+        private final String transferEncoding;
+        private final Converter<T, M> valueConverter;
+
+        public PartMap(Method method, int i, Converter<T, M> converter, String str) {
+            this.method = method;
+            this.p = i;
+            this.valueConverter = converter;
+            this.transferEncoding = str;
+        }
+
+        @Override // retrofit2.ParameterHandler
+        public void apply(RequestBuilder requestBuilder, Map<String, T> map) throws IOException {
+            if (map != null) {
+                for (Map.Entry<String, T> entry : map.entrySet()) {
+                    String key = entry.getKey();
+                    if (key != null) {
+                        T value = entry.getValue();
+                        if (value != null) {
+                            requestBuilder.addPart(AbstractC0105a.I("Content-Disposition", w.o("form-data; name=\"", key, "\""), "Content-Transfer-Encoding", this.transferEncoding), this.valueConverter.convert(value));
+                        } else {
+                            throw Utils.parameterError(this.method, this.p, w.o("Part map contained null value for key '", key, "'."), new Object[0]);
+                        }
+                    } else {
+                        throw Utils.parameterError(this.method, this.p, "Part map contained null key.", new Object[0]);
+                    }
+                }
+                return;
+            }
+            throw Utils.parameterError(this.method, this.p, "Part map was null.", new Object[0]);
+        }
+    }
+
+    /* loaded from: classes3.dex */
+    public static final class Path<T> extends ParameterHandler<T> {
+        private final boolean encoded;
+        private final Method method;
+        private final String name;
+        private final int p;
+        private final Converter<T, String> valueConverter;
+
+        public Path(Method method, int i, String str, Converter<T, String> converter, boolean z3) {
+            this.method = method;
+            this.p = i;
+            Objects.requireNonNull(str, "name == null");
+            this.name = str;
+            this.valueConverter = converter;
+            this.encoded = z3;
+        }
+
+        @Override // retrofit2.ParameterHandler
+        public void apply(RequestBuilder requestBuilder, T t2) throws IOException {
+            if (t2 == null) {
+                throw Utils.parameterError(this.method, this.p, w.r(new StringBuilder("Path parameter \""), this.name, "\" value must not be null."), new Object[0]);
+            }
+            requestBuilder.addPathParam(this.name, this.valueConverter.convert(t2), this.encoded);
+        }
+    }
+
+    /* loaded from: classes3.dex */
+    public static final class Query<T> extends ParameterHandler<T> {
+        private final boolean encoded;
+        private final String name;
+        private final Converter<T, String> valueConverter;
+
+        public Query(String str, Converter<T, String> converter, boolean z3) {
+            Objects.requireNonNull(str, "name == null");
+            this.name = str;
+            this.valueConverter = converter;
+            this.encoded = z3;
+        }
+
+        @Override // retrofit2.ParameterHandler
+        public void apply(RequestBuilder requestBuilder, T t2) throws IOException {
+            String convert;
+            if (t2 == null || (convert = this.valueConverter.convert(t2)) == null) {
+                return;
+            }
+            requestBuilder.addQueryParam(this.name, convert, this.encoded);
+        }
+    }
+
+    /* loaded from: classes3.dex */
+    public static final class QueryMap<T> extends ParameterHandler<Map<String, T>> {
+        private final boolean encoded;
+        private final Method method;
+        private final int p;
+        private final Converter<T, String> valueConverter;
+
+        public QueryMap(Method method, int i, Converter<T, String> converter, boolean z3) {
+            this.method = method;
+            this.p = i;
+            this.valueConverter = converter;
+            this.encoded = z3;
+        }
+
+        @Override // retrofit2.ParameterHandler
+        public void apply(RequestBuilder requestBuilder, Map<String, T> map) throws IOException {
+            if (map != null) {
+                for (Map.Entry<String, T> entry : map.entrySet()) {
+                    String key = entry.getKey();
+                    if (key != null) {
+                        T value = entry.getValue();
+                        if (value != null) {
+                            String convert = this.valueConverter.convert(value);
+                            if (convert != null) {
+                                requestBuilder.addQueryParam(key, convert, this.encoded);
+                            } else {
+                                throw Utils.parameterError(this.method, this.p, "Query map value '" + value + "' converted to null by " + this.valueConverter.getClass().getName() + " for key '" + key + "'.", new Object[0]);
+                            }
+                        } else {
+                            throw Utils.parameterError(this.method, this.p, w.o("Query map contained null value for key '", key, "'."), new Object[0]);
+                        }
+                    } else {
+                        throw Utils.parameterError(this.method, this.p, "Query map contained null key.", new Object[0]);
+                    }
+                }
+                return;
+            }
+            throw Utils.parameterError(this.method, this.p, "Query map was null", new Object[0]);
+        }
+    }
+
+    /* loaded from: classes3.dex */
+    public static final class QueryName<T> extends ParameterHandler<T> {
+        private final boolean encoded;
+        private final Converter<T, String> nameConverter;
+
+        public QueryName(Converter<T, String> converter, boolean z3) {
+            this.nameConverter = converter;
+            this.encoded = z3;
+        }
+
+        @Override // retrofit2.ParameterHandler
+        public void apply(RequestBuilder requestBuilder, T t2) throws IOException {
+            if (t2 == null) {
+                return;
+            }
+            requestBuilder.addQueryParam(this.nameConverter.convert(t2), null, this.encoded);
+        }
+    }
+
+    /* loaded from: classes3.dex */
+    public static final class RawPart extends ParameterHandler<C> {
+        static final RawPart INSTANCE = new RawPart();
+
+        private RawPart() {
+        }
+
+        @Override // retrofit2.ParameterHandler
+        public void apply(RequestBuilder requestBuilder, C c4) {
+            if (c4 != null) {
+                requestBuilder.addPart(c4);
+            }
+        }
+    }
+
+    /* loaded from: classes3.dex */
+    public static final class RelativeUrl extends ParameterHandler<Object> {
+        private final Method method;
+        private final int p;
+
+        public RelativeUrl(Method method, int i) {
+            this.method = method;
+            this.p = i;
+        }
+
+        @Override // retrofit2.ParameterHandler
+        public void apply(RequestBuilder requestBuilder, Object obj) {
+            if (obj == null) {
+                throw Utils.parameterError(this.method, this.p, "@Url parameter is null.", new Object[0]);
+            }
+            requestBuilder.setRelativeUrl(obj);
+        }
+    }
+
+    /* loaded from: classes3.dex */
+    public static final class Tag<T> extends ParameterHandler<T> {
+        final Class<T> cls;
+
+        public Tag(Class<T> cls) {
+            this.cls = cls;
+        }
+
+        @Override // retrofit2.ParameterHandler
+        public void apply(RequestBuilder requestBuilder, T t2) {
+            requestBuilder.addTag(this.cls, t2);
+        }
+    }
+
+    public abstract void apply(RequestBuilder requestBuilder, T t2) throws IOException;
+
+    public final ParameterHandler<Object> array() {
+        return new ParameterHandler<Object>() { // from class: retrofit2.ParameterHandler.2
+            /* JADX WARN: Multi-variable type inference failed */
+            @Override // retrofit2.ParameterHandler
+            public 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));
+                }
+            }
+        };
+    }
+
+    public final ParameterHandler<Iterable<T>> iterable() {
+        return new ParameterHandler<Iterable<T>>() { // from class: retrofit2.ParameterHandler.1
+            @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());
+                }
+            }
+        };
+    }
+}

apk_decompiled/sources/retrofit2/Platform.java

@@ -0,0 +1,102 @@
+package retrofit2;
+
+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.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.concurrent.Executor;
+import org.codehaus.mojo.animal_sniffer.IgnoreJRERequirement;
+import retrofit2.CallAdapter;
+import retrofit2.Converter;
+
+/* loaded from: classes3.dex */
+class Platform {
+    private static final Platform PLATFORM = findPlatform();
+    private final boolean hasJava8Types;
+    private final Constructor<MethodHandles.Lookup> lookupConstructor;
+
+    /* loaded from: classes3.dex */
+    public static final class Android extends Platform {
+
+        /* loaded from: classes3.dex */
+        public static final class MainThreadExecutor implements Executor {
+            private final Handler handler = new Handler(Looper.getMainLooper());
+
+            @Override // java.util.concurrent.Executor
+            public void execute(Runnable runnable) {
+                this.handler.post(runnable);
+            }
+        }
+
+        public Android() {
+            super(true);
+        }
+
+        @Override // retrofit2.Platform
+        public Executor defaultCallbackExecutor() {
+            return new MainThreadExecutor();
+        }
+
+        @Override // retrofit2.Platform
+        public Object invokeDefaultMethod(Method method, Class<?> cls, Object obj, Object... objArr) throws Throwable {
+            return super.invokeDefaultMethod(method, cls, obj, objArr);
+        }
+    }
+
+    public Platform(boolean z3) {
+        this.hasJava8Types = z3;
+        Constructor<MethodHandles.Lookup> constructor = null;
+        if (z3) {
+            try {
+                constructor = MethodHandles.Lookup.class.getDeclaredConstructor(Class.class, Integer.TYPE);
+                constructor.setAccessible(true);
+            } catch (NoClassDefFoundError | NoSuchMethodException unused) {
+            }
+        }
+        this.lookupConstructor = constructor;
+    }
+
+    private static Platform findPlatform() {
+        return "Dalvik".equals(System.getProperty("java.vm.name")) ? new Android() : new Platform(true);
+    }
+
+    public static Platform get() {
+        return PLATFORM;
+    }
+
+    public List<? extends CallAdapter.Factory> defaultCallAdapterFactories(Executor executor) {
+        DefaultCallAdapterFactory defaultCallAdapterFactory = new DefaultCallAdapterFactory(executor);
+        return this.hasJava8Types ? Arrays.asList(CompletableFutureCallAdapterFactory.INSTANCE, defaultCallAdapterFactory) : Collections.singletonList(defaultCallAdapterFactory);
+    }
+
+    public int defaultCallAdapterFactoriesSize() {
+        return this.hasJava8Types ? 2 : 1;
+    }
+
+    public Executor defaultCallbackExecutor() {
+        return null;
+    }
+
+    public List<? extends Converter.Factory> defaultConverterFactories() {
+        return this.hasJava8Types ? Collections.singletonList(OptionalConverterFactory.INSTANCE) : Collections.EMPTY_LIST;
+    }
+
+    public int defaultConverterFactoriesSize() {
+        return this.hasJava8Types ? 1 : 0;
+    }
+
+    @IgnoreJRERequirement
+    public Object invokeDefaultMethod(Method method, Class<?> cls, Object obj, Object... objArr) throws Throwable {
+        Constructor<MethodHandles.Lookup> constructor = this.lookupConstructor;
+        return (constructor != null ? constructor.newInstance(cls, -1) : MethodHandles.lookup()).unreflectSpecial(method, cls).bindTo(obj).invokeWithArguments(objArr);
+    }
+
+    @IgnoreJRERequirement
+    public boolean isDefaultMethod(Method method) {
+        return this.hasJava8Types && method.isDefault();
+    }
+}

apk_decompiled/sources/retrofit2/RequestBuilder.java

@@ -0,0 +1,330 @@
+package retrofit2;
+
+import e3.A;
+import e3.B;
+import e3.C;
+import e3.C0329o;
+import e3.C0331q;
+import e3.C0333t;
+import e3.C0334u;
+import e3.C0335v;
+import e3.D;
+import e3.H;
+import e3.M;
+import e3.r;
+import e3.w;
+import e3.z;
+import f3.c;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.regex.Pattern;
+import kotlin.UByte;
+import kotlin.jvm.internal.Intrinsics;
+import r3.C0576h;
+import r3.InterfaceC0577i;
+
+/* JADX INFO: Access modifiers changed from: package-private */
+/* loaded from: classes3.dex */
+public final class RequestBuilder {
+    private static final String PATH_SEGMENT_ALWAYS_ENCODE_SET = " \"<>^`{}|\\?#";
+    private final w baseUrl;
+    private M body;
+    private A contentType;
+    private C0331q formBuilder;
+    private final boolean hasBody;
+    private final C0333t headersBuilder;
+    private final String method;
+    private B multipartBuilder;
+    private String relativeUrl;
+    private final H requestBuilder = new H();
+    private C0335v urlBuilder;
+    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 Pattern PATH_TRAVERSAL = Pattern.compile("(.*/)?(\\.|%2e|%2E){1,2}(/.*)?");
+
+    /* loaded from: classes3.dex */
+    public static class ContentTypeOverridingRequestBody extends M {
+        private final A contentType;
+        private final M delegate;
+
+        public ContentTypeOverridingRequestBody(M m4, A a2) {
+            this.delegate = m4;
+            this.contentType = a2;
+        }
+
+        @Override // e3.M
+        public long contentLength() throws IOException {
+            return this.delegate.contentLength();
+        }
+
+        @Override // e3.M
+        public A contentType() {
+            return this.contentType;
+        }
+
+        @Override // e3.M
+        public void writeTo(InterfaceC0577i interfaceC0577i) throws IOException {
+            this.delegate.writeTo(interfaceC0577i);
+        }
+    }
+
+    public RequestBuilder(String str, w wVar, String str2, C0334u c0334u, A a2, boolean z3, boolean z4, boolean z5) {
+        this.method = str;
+        this.baseUrl = wVar;
+        this.relativeUrl = str2;
+        this.contentType = a2;
+        this.hasBody = z3;
+        if (c0334u != null) {
+            this.headersBuilder = c0334u.c();
+        } else {
+            this.headersBuilder = new C0333t();
+        }
+        if (z4) {
+            this.formBuilder = new C0331q();
+            return;
+        }
+        if (z5) {
+            B b4 = new B();
+            this.multipartBuilder = b4;
+            A type = D.f6208f;
+            Intrinsics.checkNotNullParameter(type, "type");
+            if (Intrinsics.areEqual(type.f6200b, "multipart")) {
+                b4.f6203b = type;
+            } else {
+                throw new IllegalArgumentException(("multipart != " + type).toString());
+            }
+        }
+    }
+
+    /* JADX WARN: Type inference failed for: r3v1, types: [java.lang.Object, r3.h] */
+    private static String canonicalizeForPath(String str, boolean z3) {
+        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 && (z3 || (codePointAt != 47 && codePointAt != 37))) {
+                i += Character.charCount(codePointAt);
+            } else {
+                ?? obj = new Object();
+                obj.p0(str, 0, i);
+                canonicalizeForPath(obj, str, i, length, z3);
+                return obj.e0();
+            }
+        }
+        return str;
+    }
+
+    public void addFormField(String name, String value, boolean z3) {
+        if (z3) {
+            C0331q c0331q = this.formBuilder;
+            c0331q.getClass();
+            Intrinsics.checkNotNullParameter(name, "name");
+            Intrinsics.checkNotNullParameter(value, "value");
+            c0331q.f6394a.add(C0329o.b(0, 0, 83, name, " \"':;<=>@[]^`{}|/\\?#&!$(),~"));
+            c0331q.f6395b.add(C0329o.b(0, 0, 83, value, " \"':;<=>@[]^`{}|/\\?#&!$(),~"));
+            return;
+        }
+        C0331q c0331q2 = this.formBuilder;
+        c0331q2.getClass();
+        Intrinsics.checkNotNullParameter(name, "name");
+        Intrinsics.checkNotNullParameter(value, "value");
+        c0331q2.f6394a.add(C0329o.b(0, 0, 91, name, " \"':;<=>@[]^`{}|/\\?#&!$(),~"));
+        c0331q2.f6395b.add(C0329o.b(0, 0, 91, value, " \"':;<=>@[]^`{}|/\\?#&!$(),~"));
+    }
+
+    public void addHeader(String str, String str2) {
+        if (!"Content-Type".equalsIgnoreCase(str)) {
+            this.headersBuilder.a(str, str2);
+            return;
+        }
+        try {
+            Pattern pattern = A.f6197d;
+            this.contentType = z.a(str2);
+        } catch (IllegalArgumentException e4) {
+            throw new IllegalArgumentException(C.w.z("Malformed content type: ", str2), e4);
+        }
+    }
+
+    public void addHeaders(C0334u headers) {
+        C0333t c0333t = this.headersBuilder;
+        c0333t.getClass();
+        Intrinsics.checkNotNullParameter(headers, "headers");
+        int size = headers.size();
+        for (int i = 0; i < size; i++) {
+            c0333t.b(headers.b(i), headers.f(i));
+        }
+    }
+
+    public void addPart(C0334u c0334u, M body) {
+        B b4 = this.multipartBuilder;
+        b4.getClass();
+        Intrinsics.checkNotNullParameter(body, "body");
+        Intrinsics.checkNotNullParameter(body, "body");
+        if ((c0334u != null ? c0334u.a("Content-Type") : null) == null) {
+            if ((c0334u != null ? c0334u.a("Content-Length") : null) == null) {
+                C part = new C(c0334u, body);
+                Intrinsics.checkNotNullParameter(part, "part");
+                b4.f6204c.add(part);
+                return;
+            }
+            throw new IllegalArgumentException("Unexpected header: Content-Length");
+        }
+        throw new IllegalArgumentException("Unexpected header: Content-Type");
+    }
+
+    public void addPathParam(String str, String str2, boolean z3) {
+        if (this.relativeUrl == null) {
+            throw new AssertionError();
+        }
+        String canonicalizeForPath = canonicalizeForPath(str2, z3);
+        String replace = this.relativeUrl.replace("{" + str + "}", canonicalizeForPath);
+        if (PATH_TRAVERSAL.matcher(replace).matches()) {
+            throw new IllegalArgumentException(C.w.z("@Path parameters shouldn't perform path traversal ('.' or '..'): ", str2));
+        }
+        this.relativeUrl = replace;
+    }
+
+    public void addQueryParam(String name, String str, boolean z3) {
+        String str2 = this.relativeUrl;
+        if (str2 != null) {
+            C0335v f2 = this.baseUrl.f(str2);
+            this.urlBuilder = f2;
+            if (f2 == null) {
+                throw new IllegalArgumentException("Malformed URL. Base: " + this.baseUrl + ", Relative: " + this.relativeUrl);
+            }
+            this.relativeUrl = null;
+        }
+        if (z3) {
+            C0335v c0335v = this.urlBuilder;
+            c0335v.getClass();
+            Intrinsics.checkNotNullParameter(name, "encodedName");
+            if (c0335v.f6411g == null) {
+                c0335v.f6411g = new ArrayList();
+            }
+            ArrayList arrayList = c0335v.f6411g;
+            Intrinsics.checkNotNull(arrayList);
+            arrayList.add(C0329o.b(0, 0, 211, name, " \"'<>#&="));
+            ArrayList arrayList2 = c0335v.f6411g;
+            Intrinsics.checkNotNull(arrayList2);
+            arrayList2.add(str != null ? C0329o.b(0, 0, 211, str, " \"'<>#&=") : null);
+            return;
+        }
+        C0335v c0335v2 = this.urlBuilder;
+        c0335v2.getClass();
+        Intrinsics.checkNotNullParameter(name, "name");
+        if (c0335v2.f6411g == null) {
+            c0335v2.f6411g = new ArrayList();
+        }
+        ArrayList arrayList3 = c0335v2.f6411g;
+        Intrinsics.checkNotNull(arrayList3);
+        arrayList3.add(C0329o.b(0, 0, 219, name, " !\"#$&'(),/:;<=>?@[]\\^`{|}~"));
+        ArrayList arrayList4 = c0335v2.f6411g;
+        Intrinsics.checkNotNull(arrayList4);
+        arrayList4.add(str != null ? C0329o.b(0, 0, 219, str, " !\"#$&'(),/:;<=>?@[]\\^`{|}~") : null);
+    }
+
+    public <T> void addTag(Class<T> cls, T t2) {
+        this.requestBuilder.f(cls, t2);
+    }
+
+    public H get() {
+        w url;
+        C0335v c0335v = this.urlBuilder;
+        if (c0335v != null) {
+            url = c0335v.a();
+        } else {
+            w wVar = this.baseUrl;
+            String link = this.relativeUrl;
+            wVar.getClass();
+            Intrinsics.checkNotNullParameter(link, "link");
+            C0335v f2 = wVar.f(link);
+            url = f2 != null ? f2.a() : null;
+            if (url == null) {
+                throw new IllegalArgumentException("Malformed URL. Base: " + this.baseUrl + ", Relative: " + this.relativeUrl);
+            }
+        }
+        M m4 = this.body;
+        if (m4 == null) {
+            C0331q c0331q = this.formBuilder;
+            if (c0331q != null) {
+                m4 = new r(c0331q.f6394a, c0331q.f6395b);
+            } else {
+                B b4 = this.multipartBuilder;
+                if (b4 != null) {
+                    ArrayList arrayList = b4.f6204c;
+                    if (arrayList.isEmpty()) {
+                        throw new IllegalStateException("Multipart body must have at least one part.");
+                    }
+                    m4 = new D(b4.f6202a, b4.f6203b, c.w(arrayList));
+                } else if (this.hasBody) {
+                    m4 = M.create((A) null, new byte[0]);
+                }
+            }
+        }
+        A a2 = this.contentType;
+        if (a2 != null) {
+            if (m4 != null) {
+                m4 = new ContentTypeOverridingRequestBody(m4, a2);
+            } else {
+                this.headersBuilder.a("Content-Type", a2.f6199a);
+            }
+        }
+        H h = this.requestBuilder;
+        h.getClass();
+        Intrinsics.checkNotNullParameter(url, "url");
+        h.f6262a = url;
+        C0334u headers = this.headersBuilder.d();
+        Intrinsics.checkNotNullParameter(headers, "headers");
+        h.f6264c = headers.c();
+        h.d(this.method, m4);
+        return h;
+    }
+
+    public void setBody(M m4) {
+        this.body = m4;
+    }
+
+    public void setRelativeUrl(Object obj) {
+        this.relativeUrl = obj.toString();
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    /* JADX WARN: Type inference failed for: r0v0 */
+    /* JADX WARN: Type inference failed for: r0v1 */
+    /* JADX WARN: Type inference failed for: r0v2, types: [r3.h] */
+    /* JADX WARN: Type inference failed for: r0v3, types: [java.lang.Object] */
+    /* JADX WARN: Type inference failed for: r0v4 */
+    /* JADX WARN: Type inference failed for: r0v5 */
+    private static void canonicalizeForPath(C0576h c0576h, String str, int i, int i4, boolean z3) {
+        ?? r02 = 0;
+        while (i < i4) {
+            int codePointAt = str.codePointAt(i);
+            if (!z3 || (codePointAt != 9 && codePointAt != 10 && codePointAt != 12 && codePointAt != 13)) {
+                if (codePointAt >= 32 && codePointAt < 127 && PATH_SEGMENT_ALWAYS_ENCODE_SET.indexOf(codePointAt) == -1 && (z3 || (codePointAt != 47 && codePointAt != 37))) {
+                    c0576h.q0(codePointAt);
+                } else {
+                    if (r02 == 0) {
+                        r02 = new Object();
+                    }
+                    r02.q0(codePointAt);
+                    while (!r02.x()) {
+                        byte readByte = r02.readByte();
+                        int i5 = readByte & UByte.MAX_VALUE;
+                        c0576h.j0(37);
+                        char[] cArr = HEX_DIGITS;
+                        c0576h.j0(cArr[(i5 >> 4) & 15]);
+                        c0576h.j0(cArr[readByte & 15]);
+                    }
+                }
+            }
+            i += Character.charCount(codePointAt);
+            r02 = r02;
+        }
+    }
+
+    public void addPart(C part) {
+        B b4 = this.multipartBuilder;
+        b4.getClass();
+        Intrinsics.checkNotNullParameter(part, "part");
+        b4.f6204c.add(part);
+    }
+}

apk_decompiled/sources/retrofit2/RequestFactory.java

@@ -0,0 +1,637 @@
+package retrofit2;
+
+import a.AbstractC0105a;
+import e3.A;
+import e3.C;
+import e3.C0334u;
+import e3.H;
+import e3.I;
+import e3.w;
+import e3.z;
+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.ArrayList;
+import java.util.LinkedHashSet;
+import java.util.Map;
+import java.util.Set;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import kotlin.coroutines.Continuation;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.text.StringsKt__StringsKt;
+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.Headers;
+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.Tag;
+import retrofit2.http.Url;
+
+/* JADX INFO: Access modifiers changed from: package-private */
+/* loaded from: classes3.dex */
+// TODO
+public final class RequestFactory {
+    private final w baseUrl;
+    private final A contentType;
+    private final boolean hasBody;
+    private final C0334u headers;
+    final String httpMethod;
+    private final boolean isFormEncoded;
+    final boolean isKotlinSuspendFunction;
+    private final boolean isMultipart;
+    private final Method method;
+    private final ParameterHandler<?>[] parameterHandlers;
+    private final String relativeUrl;
+
+    /* loaded from: classes3.dex */
+    public static final class Builder {
+        A contentType;
+        boolean gotBody;
+        boolean gotField;
+        boolean gotPart;
+        boolean gotPath;
+        boolean gotQuery;
+        boolean gotQueryMap;
+        boolean gotQueryName;
+        boolean gotUrl;
+        boolean hasBody;
+        C0334u headers;
+        String httpMethod;
+        boolean isFormEncoded;
+        boolean isKotlinSuspendFunction;
+        boolean isMultipart;
+        final Method method;
+        final Annotation[] methodAnnotations;
+        final Annotation[][] parameterAnnotationsArray;
+        ParameterHandler<?>[] parameterHandlers;
+        final Type[] parameterTypes;
+        String relativeUrl;
+        Set<String> relativeUrlParamNames;
+        final Retrofit retrofit;
+        private static final Pattern PARAM_URL_REGEX = Pattern.compile("\\{([a-zA-Z][a-zA-Z0-9_-]*)\\}");
+        private static final String PARAM = "[a-zA-Z][a-zA-Z0-9_-]*";
+        private static final Pattern PARAM_NAME_REGEX = Pattern.compile(PARAM);
+
+        public Builder(Retrofit retrofit, Method method) {
+            this.retrofit = retrofit;
+            this.method = method;
+            this.methodAnnotations = method.getAnnotations();
+            this.parameterTypes = method.getGenericParameterTypes();
+            this.parameterAnnotationsArray = method.getParameterAnnotations();
+        }
+
+        private 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;
+        }
+
+        private C0334u parseHeaders(String[] strArr) {
+            CharSequence trim;
+            ArrayList arrayList = new ArrayList(20);
+            for (String str : strArr) {
+                int indexOf = str.indexOf(58);
+                if (indexOf == -1 || indexOf == 0 || indexOf == str.length() - 1) {
+                    throw Utils.methodError(this.method, "@Headers value must be in the form \"Name: Value\". Found: \"%s\"", str);
+                }
+                String name = str.substring(0, indexOf);
+                String value = str.substring(indexOf + 1).trim();
+                if ("Content-Type".equalsIgnoreCase(name)) {
+                    try {
+                        Pattern pattern = A.f6197d;
+                        this.contentType = z.a(value);
+                    } catch (IllegalArgumentException e4) {
+                        throw Utils.methodError(this.method, e4, "Malformed content type: %s", value);
+                    }
+                } else {
+                    Intrinsics.checkNotNullParameter(name, "name");
+                    Intrinsics.checkNotNullParameter(value, "value");
+                    AbstractC0105a.g(name);
+                    AbstractC0105a.h(value, name);
+                    Intrinsics.checkNotNullParameter(name, "name");
+                    Intrinsics.checkNotNullParameter(value, "value");
+                    arrayList.add(name);
+                    trim = StringsKt__StringsKt.trim((CharSequence) value);
+                    arrayList.add(trim.toString());
+                }
+            }
+            return new C0334u((String[]) arrayList.toArray(new String[0]));
+        }
+
+        private void parseHttpMethodAndPath(String str, String str2, boolean z3) {
+            String str3 = this.httpMethod;
+            if (str3 != null) {
+                throw Utils.methodError(this.method, "Only one HTTP method is allowed. Found: %s and %s.", str3, str);
+            }
+            this.httpMethod = str;
+            this.hasBody = z3;
+            if (str2.isEmpty()) {
+                return;
+            }
+            int indexOf = str2.indexOf(63);
+            if (indexOf != -1 && indexOf < str2.length() - 1) {
+                String substring = str2.substring(indexOf + 1);
+                if (PARAM_URL_REGEX.matcher(substring).find()) {
+                    throw Utils.methodError(this.method, "URL query string \"%s\" must not have replace block. For dynamic query parameters use @Query.", substring);
+                }
+            }
+            this.relativeUrl = str2;
+            this.relativeUrlParamNames = 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);
+                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 Headers) {
+                String[] value = ((Headers) annotation).value();
+                if (value.length == 0) {
+                    throw Utils.methodError(this.method, "@Headers annotation is empty.", new Object[0]);
+                }
+                this.headers = parseHeaders(value);
+                return;
+            }
+            if (annotation instanceof Multipart) {
+                if (this.isFormEncoded) {
+                    throw Utils.methodError(this.method, "Only one encoding annotation is allowed.", new Object[0]);
+                }
+                this.isMultipart = true;
+            } else if (annotation instanceof FormUrlEncoded) {
+                if (this.isMultipart) {
+                    throw Utils.methodError(this.method, "Only one encoding annotation is allowed.", new Object[0]);
+                }
+                this.isFormEncoded = true;
+            }
+        }
+
+        private ParameterHandler<?> parseParameter(int i, Type type, Annotation[] annotationArr, boolean z3) {
+            ParameterHandler<?> parameterHandler;
+            if (annotationArr != null) {
+                parameterHandler = null;
+                for (Annotation annotation : annotationArr) {
+                    ParameterHandler<?> parseParameterAnnotation = parseParameterAnnotation(i, type, annotationArr, annotation);
+                    if (parseParameterAnnotation != null) {
+                        if (parameterHandler != null) {
+                            throw Utils.parameterError(this.method, i, "Multiple Retrofit annotations found, only one allowed.", new Object[0]);
+                        }
+                        parameterHandler = parseParameterAnnotation;
+                    }
+                }
+            } else {
+                parameterHandler = null;
+            }
+            if (parameterHandler != null) {
+                return parameterHandler;
+            }
+            if (z3) {
+                try {
+                    if (Utils.getRawType(type) == Continuation.class) {
+                        this.isKotlinSuspendFunction = true;
+                        return null;
+                    }
+                } catch (NoClassDefFoundError unused) {
+                }
+            }
+            throw Utils.parameterError(this.method, i, "No Retrofit annotation found.", new Object[0]);
+        }
+
+        private ParameterHandler<?> parseParameterAnnotation(int i, Type type, Annotation[] annotationArr, Annotation annotation) {
+            if (annotation instanceof Url) {
+                validateResolvableType(i, type);
+                if (this.gotUrl) {
+                    throw Utils.parameterError(this.method, i, "Multiple @Url method annotations found.", new Object[0]);
+                }
+                if (this.gotPath) {
+                    throw Utils.parameterError(this.method, i, "@Path parameters may not be used with @Url.", new Object[0]);
+                }
+                if (this.gotQuery) {
+                    throw Utils.parameterError(this.method, i, "A @Url parameter must not come after a @Query.", new Object[0]);
+                }
+                if (this.gotQueryName) {
+                    throw Utils.parameterError(this.method, i, "A @Url parameter must not come after a @QueryName.", new Object[0]);
+                }
+                if (this.gotQueryMap) {
+                    throw Utils.parameterError(this.method, i, "A @Url parameter must not come after a @QueryMap.", new Object[0]);
+                }
+                if (this.relativeUrl != null) {
+                    throw Utils.parameterError(this.method, i, "@Url cannot be used with @%s URL", this.httpMethod);
+                }
+                this.gotUrl = true;
+                if (type == w.class || type == String.class || type == URI.class || ((type instanceof Class) && "android.net.Uri".equals(((Class) type).getName()))) {
+                    return new ParameterHandler.RelativeUrl(this.method, i);
+                }
+                throw Utils.parameterError(this.method, i, "@Url must be okhttp3.HttpUrl, String, java.net.URI, or android.net.Uri type.", new Object[0]);
+            }
+            if (annotation instanceof Path) {
+                validateResolvableType(i, type);
+                if (this.gotQuery) {
+                    throw Utils.parameterError(this.method, i, "A @Path parameter must not come after a @Query.", new Object[0]);
+                }
+                if (this.gotQueryName) {
+                    throw Utils.parameterError(this.method, i, "A @Path parameter must not come after a @QueryName.", new Object[0]);
+                }
+                if (this.gotQueryMap) {
+                    throw Utils.parameterError(this.method, i, "A @Path parameter must not come after a @QueryMap.", new Object[0]);
+                }
+                if (this.gotUrl) {
+                    throw Utils.parameterError(this.method, i, "@Path parameters may not be used with @Url.", new Object[0]);
+                }
+                if (this.relativeUrl == null) {
+                    throw Utils.parameterError(this.method, 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(this.method, i, value, this.retrofit.stringConverter(type, annotationArr), path.encoded());
+            }
+            if (annotation instanceof Query) {
+                validateResolvableType(i, type);
+                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)) {
+                    if (!rawType.isArray()) {
+                        return new ParameterHandler.Query(value2, this.retrofit.stringConverter(type, annotationArr), encoded);
+                    }
+                    return new ParameterHandler.Query(value2, this.retrofit.stringConverter(boxIfPrimitive(rawType.getComponentType()), annotationArr), encoded).array();
+                }
+                if (type instanceof ParameterizedType) {
+                    return new ParameterHandler.Query(value2, this.retrofit.stringConverter(Utils.getParameterUpperBound(0, (ParameterizedType) type), annotationArr), encoded).iterable();
+                }
+                throw Utils.parameterError(this.method, i, rawType.getSimpleName() + " must include generic type (e.g., " + rawType.getSimpleName() + "<String>)", new Object[0]);
+            }
+            if (annotation instanceof QueryName) {
+                validateResolvableType(i, type);
+                boolean encoded2 = ((QueryName) annotation).encoded();
+                Class<?> rawType2 = Utils.getRawType(type);
+                this.gotQueryName = true;
+                if (!Iterable.class.isAssignableFrom(rawType2)) {
+                    if (!rawType2.isArray()) {
+                        return new ParameterHandler.QueryName(this.retrofit.stringConverter(type, annotationArr), encoded2);
+                    }
+                    return new ParameterHandler.QueryName(this.retrofit.stringConverter(boxIfPrimitive(rawType2.getComponentType()), annotationArr), encoded2).array();
+                }
+                if (type instanceof ParameterizedType) {
+                    return new ParameterHandler.QueryName(this.retrofit.stringConverter(Utils.getParameterUpperBound(0, (ParameterizedType) type), annotationArr), encoded2).iterable();
+                }
+                throw Utils.parameterError(this.method, i, rawType2.getSimpleName() + " must include generic type (e.g., " + rawType2.getSimpleName() + "<String>)", new Object[0]);
+            }
+            if (annotation instanceof QueryMap) {
+                validateResolvableType(i, type);
+                Class<?> rawType3 = Utils.getRawType(type);
+                this.gotQueryMap = true;
+                if (!Map.class.isAssignableFrom(rawType3)) {
+                    throw Utils.parameterError(this.method, i, "@QueryMap parameter type must be Map.", new Object[0]);
+                }
+                Type supertype = Utils.getSupertype(type, rawType3, Map.class);
+                if (!(supertype instanceof ParameterizedType)) {
+                    throw Utils.parameterError(this.method, 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.method, i, this.retrofit.stringConverter(Utils.getParameterUpperBound(1, parameterizedType), annotationArr), ((QueryMap) annotation).encoded());
+                }
+                throw Utils.parameterError(this.method, i, "@QueryMap keys must be of type String: " + parameterUpperBound, new Object[0]);
+            }
+            if (annotation instanceof Header) {
+                validateResolvableType(i, type);
+                String value3 = ((Header) annotation).value();
+                Class<?> rawType4 = Utils.getRawType(type);
+                if (!Iterable.class.isAssignableFrom(rawType4)) {
+                    if (!rawType4.isArray()) {
+                        return new ParameterHandler.Header(value3, this.retrofit.stringConverter(type, annotationArr));
+                    }
+                    return new ParameterHandler.Header(value3, this.retrofit.stringConverter(boxIfPrimitive(rawType4.getComponentType()), annotationArr)).array();
+                }
+                if (type instanceof ParameterizedType) {
+                    return new ParameterHandler.Header(value3, this.retrofit.stringConverter(Utils.getParameterUpperBound(0, (ParameterizedType) type), annotationArr)).iterable();
+                }
+                throw Utils.parameterError(this.method, i, rawType4.getSimpleName() + " must include generic type (e.g., " + rawType4.getSimpleName() + "<String>)", new Object[0]);
+            }
+            if (annotation instanceof HeaderMap) {
+                if (type == C0334u.class) {
+                    return new ParameterHandler.Headers(this.method, i);
+                }
+                validateResolvableType(i, type);
+                Class<?> rawType5 = Utils.getRawType(type);
+                if (!Map.class.isAssignableFrom(rawType5)) {
+                    throw Utils.parameterError(this.method, i, "@HeaderMap parameter type must be Map.", new Object[0]);
+                }
+                Type supertype2 = Utils.getSupertype(type, rawType5, Map.class);
+                if (!(supertype2 instanceof ParameterizedType)) {
+                    throw Utils.parameterError(this.method, 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.method, i, this.retrofit.stringConverter(Utils.getParameterUpperBound(1, parameterizedType2), annotationArr));
+                }
+                throw Utils.parameterError(this.method, i, "@HeaderMap keys must be of type String: " + parameterUpperBound2, new Object[0]);
+            }
+            if (annotation instanceof Field) {
+                validateResolvableType(i, type);
+                if (!this.isFormEncoded) {
+                    throw Utils.parameterError(this.method, 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)) {
+                    if (!rawType6.isArray()) {
+                        return new ParameterHandler.Field(value4, this.retrofit.stringConverter(type, annotationArr), encoded3);
+                    }
+                    return new ParameterHandler.Field(value4, this.retrofit.stringConverter(boxIfPrimitive(rawType6.getComponentType()), annotationArr), encoded3).array();
+                }
+                if (type instanceof ParameterizedType) {
+                    return new ParameterHandler.Field(value4, this.retrofit.stringConverter(Utils.getParameterUpperBound(0, (ParameterizedType) type), annotationArr), encoded3).iterable();
+                }
+                throw Utils.parameterError(this.method, i, rawType6.getSimpleName() + " must include generic type (e.g., " + rawType6.getSimpleName() + "<String>)", new Object[0]);
+            }
+            if (annotation instanceof FieldMap) {
+                validateResolvableType(i, type);
+                if (!this.isFormEncoded) {
+                    throw Utils.parameterError(this.method, i, "@FieldMap parameters can only be used with form encoding.", new Object[0]);
+                }
+                Class<?> rawType7 = Utils.getRawType(type);
+                if (!Map.class.isAssignableFrom(rawType7)) {
+                    throw Utils.parameterError(this.method, i, "@FieldMap parameter type must be Map.", new Object[0]);
+                }
+                Type supertype3 = Utils.getSupertype(type, rawType7, Map.class);
+                if (!(supertype3 instanceof ParameterizedType)) {
+                    throw Utils.parameterError(this.method, 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 stringConverter = this.retrofit.stringConverter(Utils.getParameterUpperBound(1, parameterizedType3), annotationArr);
+                    this.gotField = true;
+                    return new ParameterHandler.FieldMap(this.method, i, stringConverter, ((FieldMap) annotation).encoded());
+                }
+                throw Utils.parameterError(this.method, i, "@FieldMap keys must be of type String: " + parameterUpperBound3, new Object[0]);
+            }
+            if (annotation instanceof Part) {
+                validateResolvableType(i, type);
+                if (!this.isMultipart) {
+                    throw Utils.parameterError(this.method, 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<?> rawType8 = Utils.getRawType(type);
+                if (value5.isEmpty()) {
+                    if (!Iterable.class.isAssignableFrom(rawType8)) {
+                        if (rawType8.isArray()) {
+                            if (C.class.isAssignableFrom(rawType8.getComponentType())) {
+                                return ParameterHandler.RawPart.INSTANCE.array();
+                            }
+                            throw Utils.parameterError(this.method, i, "@Part annotation must supply a name or use MultipartBody.Part parameter type.", new Object[0]);
+                        }
+                        if (C.class.isAssignableFrom(rawType8)) {
+                            return ParameterHandler.RawPart.INSTANCE;
+                        }
+                        throw Utils.parameterError(this.method, i, "@Part annotation must supply a name or use MultipartBody.Part parameter type.", new Object[0]);
+                    }
+                    if (type instanceof ParameterizedType) {
+                        if (C.class.isAssignableFrom(Utils.getRawType(Utils.getParameterUpperBound(0, (ParameterizedType) type)))) {
+                            return ParameterHandler.RawPart.INSTANCE.iterable();
+                        }
+                        throw Utils.parameterError(this.method, i, "@Part annotation must supply a name or use MultipartBody.Part parameter type.", new Object[0]);
+                    }
+                    throw Utils.parameterError(this.method, i, rawType8.getSimpleName() + " must include generic type (e.g., " + rawType8.getSimpleName() + "<String>)", new Object[0]);
+                }
+                C0334u I3 = AbstractC0105a.I("Content-Disposition", C.w.o("form-data; name=\"", value5, "\""), "Content-Transfer-Encoding", part.encoding());
+                if (!Iterable.class.isAssignableFrom(rawType8)) {
+                    if (!rawType8.isArray()) {
+                        if (C.class.isAssignableFrom(rawType8)) {
+                            throw Utils.parameterError(this.method, i, "@Part parameters using the MultipartBody.Part must not include a part name in the annotation.", new Object[0]);
+                        }
+                        return new ParameterHandler.Part(this.method, i, I3, this.retrofit.requestBodyConverter(type, annotationArr, this.methodAnnotations));
+                    }
+                    Class<?> boxIfPrimitive = boxIfPrimitive(rawType8.getComponentType());
+                    if (C.class.isAssignableFrom(boxIfPrimitive)) {
+                        throw Utils.parameterError(this.method, i, "@Part parameters using the MultipartBody.Part must not include a part name in the annotation.", new Object[0]);
+                    }
+                    return new ParameterHandler.Part(this.method, i, I3, this.retrofit.requestBodyConverter(boxIfPrimitive, annotationArr, this.methodAnnotations)).array();
+                }
+                if (type instanceof ParameterizedType) {
+                    Type parameterUpperBound4 = Utils.getParameterUpperBound(0, (ParameterizedType) type);
+                    if (C.class.isAssignableFrom(Utils.getRawType(parameterUpperBound4))) {
+                        throw Utils.parameterError(this.method, i, "@Part parameters using the MultipartBody.Part must not include a part name in the annotation.", new Object[0]);
+                    }
+                    return new ParameterHandler.Part(this.method, i, I3, this.retrofit.requestBodyConverter(parameterUpperBound4, annotationArr, this.methodAnnotations)).iterable();
+                }
+                throw Utils.parameterError(this.method, i, rawType8.getSimpleName() + " must include generic type (e.g., " + rawType8.getSimpleName() + "<String>)", new Object[0]);
+            }
+            if (annotation instanceof PartMap) {
+                validateResolvableType(i, type);
+                if (!this.isMultipart) {
+                    throw Utils.parameterError(this.method, i, "@PartMap parameters can only be used with multipart encoding.", new Object[0]);
+                }
+                this.gotPart = true;
+                Class<?> rawType9 = Utils.getRawType(type);
+                if (!Map.class.isAssignableFrom(rawType9)) {
+                    throw Utils.parameterError(this.method, i, "@PartMap parameter type must be Map.", new Object[0]);
+                }
+                Type supertype4 = Utils.getSupertype(type, rawType9, Map.class);
+                if (!(supertype4 instanceof ParameterizedType)) {
+                    throw Utils.parameterError(this.method, i, "Map must include generic types (e.g., Map<String, String>)", new Object[0]);
+                }
+                ParameterizedType parameterizedType4 = (ParameterizedType) supertype4;
+                Type parameterUpperBound5 = Utils.getParameterUpperBound(0, parameterizedType4);
+                if (String.class != parameterUpperBound5) {
+                    throw Utils.parameterError(this.method, i, "@PartMap keys must be of type String: " + parameterUpperBound5, new Object[0]);
+                }
+                Type parameterUpperBound6 = Utils.getParameterUpperBound(1, parameterizedType4);
+                if (C.class.isAssignableFrom(Utils.getRawType(parameterUpperBound6))) {
+                    throw Utils.parameterError(this.method, 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.method, i, this.retrofit.requestBodyConverter(parameterUpperBound6, annotationArr, this.methodAnnotations), ((PartMap) annotation).encoding());
+            }
+            if (annotation instanceof Body) {
+                validateResolvableType(i, type);
+                if (this.isFormEncoded || this.isMultipart) {
+                    throw Utils.parameterError(this.method, i, "@Body parameters cannot be used with form or multi-part encoding.", new Object[0]);
+                }
+                if (this.gotBody) {
+                    throw Utils.parameterError(this.method, i, "Multiple @Body method annotations found.", new Object[0]);
+                }
+                try {
+                    Converter requestBodyConverter = this.retrofit.requestBodyConverter(type, annotationArr, this.methodAnnotations);
+                    this.gotBody = true;
+                    return new ParameterHandler.Body(this.method, i, requestBodyConverter);
+                } catch (RuntimeException e4) {
+                    throw Utils.parameterError(this.method, e4, i, "Unable to create @Body converter for %s", type);
+                }
+            }
+            if (!(annotation instanceof Tag)) {
+                return null;
+            }
+            validateResolvableType(i, type);
+            Class<?> rawType10 = Utils.getRawType(type);
+            for (int i4 = i - 1; i4 >= 0; i4--) {
+                ParameterHandler<?> parameterHandler = this.parameterHandlers[i4];
+                if ((parameterHandler instanceof ParameterHandler.Tag) && ((ParameterHandler.Tag) parameterHandler).cls.equals(rawType10)) {
+                    throw Utils.parameterError(this.method, i, "@Tag type " + rawType10.getName() + " is duplicate of parameter #" + (i4 + 1) + " and would always overwrite its value.", new Object[0]);
+                }
+            }
+            return new ParameterHandler.Tag(rawType10);
+        }
+
+        public 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;
+        }
+
+        private void validatePathName(int i, String str) {
+            if (!PARAM_NAME_REGEX.matcher(str).matches()) {
+                throw Utils.parameterError(this.method, i, "@Path parameter name must match %s. Found: %s", PARAM_URL_REGEX.pattern(), str);
+            }
+            if (!this.relativeUrlParamNames.contains(str)) {
+                throw Utils.parameterError(this.method, i, "URL \"%s\" does not contain \"{%s}\".", this.relativeUrl, str);
+            }
+        }
+
+        private void validateResolvableType(int i, Type type) {
+            if (Utils.hasUnresolvableType(type)) {
+                throw Utils.parameterError(this.method, i, "Parameter type must not include a type variable or wildcard: %s", type);
+            }
+        }
+
+        public RequestFactory build() {
+            for (Annotation annotation : this.methodAnnotations) {
+                parseMethodAnnotation(annotation);
+            }
+            if (this.httpMethod == null) {
+                throw Utils.methodError(this.method, "HTTP method annotation is required (e.g., @GET, @POST, etc.).", new Object[0]);
+            }
+            if (!this.hasBody) {
+                if (this.isMultipart) {
+                    throw Utils.methodError(this.method, "Multipart can only be specified on HTTP methods with request body (e.g., @POST).", new Object[0]);
+                }
+                if (this.isFormEncoded) {
+                    throw Utils.methodError(this.method, "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];
+            int i = length - 1;
+            int i4 = 0;
+            while (i4 < length) {
+                this.parameterHandlers[i4] = parseParameter(i4, this.parameterTypes[i4], this.parameterAnnotationsArray[i4], i4 == i);
+                i4++;
+            }
+            if (this.relativeUrl == null && !this.gotUrl) {
+                throw Utils.methodError(this.method, "Missing either @%s URL or @Url parameter.", this.httpMethod);
+            }
+            boolean z3 = this.isFormEncoded;
+            if (!z3 && !this.isMultipart && !this.hasBody && this.gotBody) {
+                throw Utils.methodError(this.method, "Non-body HTTP method cannot contain @Body.", new Object[0]);
+            }
+            if (z3 && !this.gotField) {
+                throw Utils.methodError(this.method, "Form-encoded method must contain at least one @Field.", new Object[0]);
+            }
+            if (!this.isMultipart || this.gotPart) {
+                return new RequestFactory(this);
+            }
+            throw Utils.methodError(this.method, "Multipart method must contain at least one @Part.", new Object[0]);
+        }
+    }
+
+    public RequestFactory(Builder builder) {
+        this.method = builder.method;
+        this.baseUrl = builder.retrofit.baseUrl;
+        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;
+        this.isKotlinSuspendFunction = builder.isKotlinSuspendFunction;
+    }
+
+    public static RequestFactory parseAnnotations(Retrofit retrofit, Method method) {
+        return new Builder(retrofit, method).build();
+    }
+
+    public I create(Object[] objArr) throws IOException {
+        ParameterHandler<?>[] parameterHandlerArr = this.parameterHandlers;
+        int length = objArr.length;
+        if (length != parameterHandlerArr.length) {
+            throw new IllegalArgumentException(com.google.android.gms.measurement.internal.a.m(C.w.t(length, "Argument count (", ") doesn't match expected count ("), parameterHandlerArr.length, ")"));
+        }
+        RequestBuilder requestBuilder = new RequestBuilder(this.httpMethod, this.baseUrl, this.relativeUrl, this.headers, this.contentType, this.hasBody, this.isFormEncoded, this.isMultipart);
+        if (this.isKotlinSuspendFunction) {
+            length--;
+        }
+        ArrayList arrayList = new ArrayList(length);
+        for (int i = 0; i < length; i++) {
+            arrayList.add(objArr[i]);
+            parameterHandlerArr[i].apply(requestBuilder, objArr[i]);
+        }
+        H h = requestBuilder.get();
+        h.f(Invocation.class, new Invocation(this.method, arrayList));
+        return h.a();
+    }
+}

apk_decompiled/sources/retrofit2/Response.java

@@ -0,0 +1,143 @@
+package retrofit2;
+
+import e3.C0334u;
+import e3.G;
+import e3.H;
+import e3.I;
+import e3.N;
+import e3.O;
+import e3.T;
+import java.util.ArrayList;
+import java.util.Objects;
+import kotlin.jvm.internal.Intrinsics;
+import retrofit2.OkHttpCall;
+
+/* loaded from: classes3.dex */
+public final class Response<T> {
+    private final T body;
+    private final T errorBody;
+    private final O rawResponse;
+
+    private Response(O o4, T t2, T t4) {
+        this.rawResponse = o4;
+        this.body = t2;
+        this.errorBody = t4;
+    }
+
+    public static <T> Response<T> error(int i, T t2) {
+        Objects.requireNonNull(t2, "body == null");
+        if (i >= 400) {
+            ArrayList arrayList = new ArrayList(20);
+            OkHttpCall.NoContentResponseBody noContentResponseBody = new OkHttpCall.NoContentResponseBody(t2.contentType(), t2.contentLength());
+            Intrinsics.checkNotNullParameter("Response.error()", "message");
+            G protocol = G.HTTP_1_1;
+            Intrinsics.checkNotNullParameter(protocol, "protocol");
+            H h = new H();
+            h.g("http://localhost/");
+            I request = h.a();
+            Intrinsics.checkNotNullParameter(request, "request");
+            if (i >= 0) {
+                return error(t2, new O(request, protocol, "Response.error()", i, null, new C0334u((String[]) arrayList.toArray(new String[0])), noContentResponseBody, null, null, null, 0L, 0L, null));
+            }
+            throw new IllegalStateException(com.google.android.gms.measurement.internal.a.l(i, "code < 0: ").toString());
+        }
+        throw new IllegalArgumentException(com.google.android.gms.measurement.internal.a.l(i, "code < 400: "));
+    }
+
+    public static <T> Response<T> success(T t2, C0334u c0334u) {
+        Objects.requireNonNull(c0334u, "headers == null");
+        N n4 = new N();
+        n4.f6282c = 200;
+        Intrinsics.checkNotNullParameter("OK", "message");
+        n4.f6283d = "OK";
+        G protocol = G.HTTP_1_1;
+        Intrinsics.checkNotNullParameter(protocol, "protocol");
+        n4.f6281b = protocol;
+        n4.c(c0334u);
+        H h = new H();
+        h.g("http://localhost/");
+        I request = h.a();
+        Intrinsics.checkNotNullParameter(request, "request");
+        n4.f6280a = request;
+        return success(t2, n4.a());
+    }
+
+    public T body() {
+        return this.body;
+    }
+
+    public int code() {
+        return this.rawResponse.f6294d;
+    }
+
+    public T errorBody() {
+        return this.errorBody;
+    }
+
+    public C0334u headers() {
+        return this.rawResponse.f6296f;
+    }
+
+    public boolean isSuccessful() {
+        return this.rawResponse.e();
+    }
+
+    public String message() {
+        return this.rawResponse.f6293c;
+    }
+
+    public O raw() {
+        return this.rawResponse;
+    }
+
+    public String toString() {
+        return this.rawResponse.toString();
+    }
+
+    public static <T> Response<T> success(T t2, O o4) {
+        Objects.requireNonNull(o4, "rawResponse == null");
+        if (o4.e()) {
+            return new Response<>(o4, t2, null);
+        }
+        throw new IllegalArgumentException("rawResponse must be successful response");
+    }
+
+    public static <T> Response<T> success(int i, T t2) {
+        if (i >= 200 && i < 300) {
+            ArrayList arrayList = new ArrayList(20);
+            Intrinsics.checkNotNullParameter("Response.success()", "message");
+            G protocol = G.HTTP_1_1;
+            Intrinsics.checkNotNullParameter(protocol, "protocol");
+            H h = new H();
+            h.g("http://localhost/");
+            I request = h.a();
+            Intrinsics.checkNotNullParameter(request, "request");
+            if (i >= 0) {
+                return success(t2, new O(request, protocol, "Response.success()", i, null, new C0334u((String[]) arrayList.toArray(new String[0])), null, null, null, null, 0L, 0L, null));
+            }
+            throw new IllegalStateException(com.google.android.gms.measurement.internal.a.l(i, "code < 0: ").toString());
+        }
+        throw new IllegalArgumentException(com.google.android.gms.measurement.internal.a.l(i, "code < 200 or >= 300: "));
+    }
+
+    public static <T> Response<T> error(T t2, O o4) {
+        Objects.requireNonNull(t2, "body == null");
+        Objects.requireNonNull(o4, "rawResponse == null");
+        if (!o4.e()) {
+            return new Response<>(o4, null, t2);
+        }
+        throw new IllegalArgumentException("rawResponse should not be successful response");
+    }
+
+    public static <T> Response<T> success(T t2) {
+        ArrayList arrayList = new ArrayList(20);
+        Intrinsics.checkNotNullParameter("OK", "message");
+        G protocol = G.HTTP_1_1;
+        Intrinsics.checkNotNullParameter(protocol, "protocol");
+        H h = new H();
+        h.g("http://localhost/");
+        I request = h.a();
+        Intrinsics.checkNotNullParameter(request, "request");
+        return success(t2, new O(request, protocol, "OK", 200, null, new C0334u((String[]) arrayList.toArray(new String[0])), null, null, null, null, 0L, 0L, null));
+    }
+}

apk_decompiled/sources/retrofit2/Retrofit.java

@@ -0,0 +1,394 @@
+package retrofit2;
+
+import e3.C0335v;
+import e3.F;
+import e3.InterfaceC0318d;
+import e3.M;
+import e3.T;
+import e3.w;
+import java.lang.annotation.Annotation;
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.lang.reflect.Proxy;
+import java.lang.reflect.Type;
+import java.net.URL;
+import java.util.ArrayDeque;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.Executor;
+import kotlin.jvm.internal.Intrinsics;
+import retrofit2.BuiltInConverters;
+import retrofit2.CallAdapter;
+import retrofit2.Converter;
+
+/* loaded from: classes3.dex */
+public final class Retrofit {
+    final w baseUrl;
+    final List<CallAdapter.Factory> callAdapterFactories;
+    final InterfaceC0318d callFactory;
+    final Executor callbackExecutor;
+    final List<Converter.Factory> converterFactories;
+    private final Map<Method, ServiceMethod<?>> serviceMethodCache = new ConcurrentHashMap();
+    final boolean validateEagerly;
+
+    public Retrofit(InterfaceC0318d interfaceC0318d, w wVar, List<Converter.Factory> list, List<CallAdapter.Factory> list2, Executor executor, boolean z3) {
+        this.callFactory = interfaceC0318d;
+        this.baseUrl = wVar;
+        this.converterFactories = list;
+        this.callAdapterFactories = list2;
+        this.callbackExecutor = executor;
+        this.validateEagerly = z3;
+    }
+
+    private void validateServiceInterface(Class<?> cls) {
+        if (!cls.isInterface()) {
+            throw new IllegalArgumentException("API declarations must be interfaces.");
+        }
+        ArrayDeque arrayDeque = new ArrayDeque(1);
+        arrayDeque.add(cls);
+        while (!arrayDeque.isEmpty()) {
+            Class<?> cls2 = (Class) arrayDeque.removeFirst();
+            if (cls2.getTypeParameters().length != 0) {
+                StringBuilder sb = new StringBuilder("Type parameters are unsupported on ");
+                sb.append(cls2.getName());
+                if (cls2 != cls) {
+                    sb.append(" which is an interface of ");
+                    sb.append(cls.getName());
+                }
+                throw new IllegalArgumentException(sb.toString());
+            }
+            Collections.addAll(arrayDeque, cls2.getInterfaces());
+        }
+        if (this.validateEagerly) {
+            Platform platform = Platform.get();
+            for (Method method : cls.getDeclaredMethods()) {
+                if (!platform.isDefaultMethod(method) && !Modifier.isStatic(method.getModifiers())) {
+                    loadServiceMethod(method);
+                }
+            }
+        }
+    }
+
+    public w 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 InterfaceC0318d 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) {
+        validateServiceInterface(cls);
+        return (T) Proxy.newProxyInstance(cls.getClassLoader(), new Class[]{cls}, new InvocationHandler() { // from class: retrofit2.Retrofit.1
+            private final Platform platform = Platform.get();
+            private final Object[] emptyArgs = new Object[0];
+
+            @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 (objArr == null) {
+                    objArr = this.emptyArgs;
+                }
+                return this.platform.isDefaultMethod(method) ? this.platform.invokeDefaultMethod(method, cls, obj, objArr) : Retrofit.this.loadServiceMethod(method).invoke(objArr);
+            }
+        });
+    }
+
+    public ServiceMethod<?> loadServiceMethod(Method method) {
+        ServiceMethod<?> serviceMethod;
+        ServiceMethod<?> serviceMethod2 = this.serviceMethodCache.get(method);
+        if (serviceMethod2 != null) {
+            return serviceMethod2;
+        }
+        synchronized (this.serviceMethodCache) {
+            try {
+                serviceMethod = this.serviceMethodCache.get(method);
+                if (serviceMethod == null) {
+                    serviceMethod = ServiceMethod.parseAnnotations(this, method);
+                    this.serviceMethodCache.put(method, serviceMethod);
+                }
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+        return serviceMethod;
+    }
+
+    public Builder newBuilder() {
+        return new Builder(this);
+    }
+
+    public CallAdapter<?, ?> nextCallAdapter(CallAdapter.Factory factory, Type type, Annotation[] annotationArr) {
+        Objects.requireNonNull(type, "returnType == null");
+        Objects.requireNonNull(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 i4 = 0; i4 < indexOf; i4++) {
+                sb.append("\n   * ");
+                sb.append(this.callAdapterFactories.get(i4).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, M> nextRequestBodyConverter(Converter.Factory factory, Type type, Annotation[] annotationArr, Annotation[] annotationArr2) {
+        Objects.requireNonNull(type, "type == null");
+        Objects.requireNonNull(annotationArr, "parameterAnnotations == null");
+        Objects.requireNonNull(annotationArr2, "methodAnnotations == null");
+        int indexOf = this.converterFactories.indexOf(factory) + 1;
+        int size = this.converterFactories.size();
+        for (int i = indexOf; i < size; i++) {
+            Converter<T, M> converter = (Converter<T, M>) 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 i4 = 0; i4 < indexOf; i4++) {
+                sb.append("\n   * ");
+                sb.append(this.converterFactories.get(i4).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, T> nextResponseBodyConverter(Converter.Factory factory, Type type, Annotation[] annotationArr) {
+        Objects.requireNonNull(type, "type == null");
+        Objects.requireNonNull(annotationArr, "annotations == null");
+        int indexOf = this.converterFactories.indexOf(factory) + 1;
+        int size = this.converterFactories.size();
+        for (int i = indexOf; i < size; i++) {
+            Converter<T, T> converter = (Converter<T, 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 i4 = 0; i4 < indexOf; i4++) {
+                sb.append("\n   * ");
+                sb.append(this.converterFactories.get(i4).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, M> requestBodyConverter(Type type, Annotation[] annotationArr, Annotation[] annotationArr2) {
+        return nextRequestBodyConverter(null, type, annotationArr, annotationArr2);
+    }
+
+    public <T> Converter<T, T> responseBodyConverter(Type type, Annotation[] annotationArr) {
+        return nextResponseBodyConverter(null, type, annotationArr);
+    }
+
+    public <T> Converter<T, String> stringConverter(Type type, Annotation[] annotationArr) {
+        Objects.requireNonNull(type, "type == null");
+        Objects.requireNonNull(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;
+    }
+
+    /* loaded from: classes3.dex */
+    public static final class Builder {
+        private w baseUrl;
+        private final List<CallAdapter.Factory> callAdapterFactories;
+        private InterfaceC0318d callFactory;
+        private Executor callbackExecutor;
+        private final List<Converter.Factory> converterFactories;
+        private final Platform platform;
+        private boolean validateEagerly;
+
+        public Builder(Platform platform) {
+            this.converterFactories = new ArrayList();
+            this.callAdapterFactories = new ArrayList();
+            this.platform = platform;
+        }
+
+        public Builder addCallAdapterFactory(CallAdapter.Factory factory) {
+            List<CallAdapter.Factory> list = this.callAdapterFactories;
+            Objects.requireNonNull(factory, "factory == null");
+            list.add(factory);
+            return this;
+        }
+
+        public Builder addConverterFactory(Converter.Factory factory) {
+            List<Converter.Factory> list = this.converterFactories;
+            Objects.requireNonNull(factory, "factory == null");
+            list.add(factory);
+            return this;
+        }
+
+        public Builder baseUrl(URL url) {
+            Objects.requireNonNull(url, "baseUrl == null");
+            String url2 = url.toString();
+            Intrinsics.checkNotNullParameter(url2, "<this>");
+            C0335v c0335v = new C0335v();
+            c0335v.d(null, url2);
+            return baseUrl(c0335v.a());
+        }
+
+        public Retrofit build() {
+            if (this.baseUrl == null) {
+                throw new IllegalStateException("Base URL required.");
+            }
+            InterfaceC0318d interfaceC0318d = this.callFactory;
+            if (interfaceC0318d == null) {
+                interfaceC0318d = new F();
+            }
+            InterfaceC0318d interfaceC0318d2 = interfaceC0318d;
+            Executor executor = this.callbackExecutor;
+            if (executor == null) {
+                executor = this.platform.defaultCallbackExecutor();
+            }
+            Executor executor2 = executor;
+            ArrayList arrayList = new ArrayList(this.callAdapterFactories);
+            arrayList.addAll(this.platform.defaultCallAdapterFactories(executor2));
+            ArrayList arrayList2 = new ArrayList(this.converterFactories.size() + 1 + this.platform.defaultConverterFactoriesSize());
+            arrayList2.add(new BuiltInConverters());
+            arrayList2.addAll(this.converterFactories);
+            arrayList2.addAll(this.platform.defaultConverterFactories());
+            return new Retrofit(interfaceC0318d2, this.baseUrl, Collections.unmodifiableList(arrayList2), Collections.unmodifiableList(arrayList), executor2, this.validateEagerly);
+        }
+
+        public List<CallAdapter.Factory> callAdapterFactories() {
+            return this.callAdapterFactories;
+        }
+
+        public Builder callFactory(InterfaceC0318d interfaceC0318d) {
+            Objects.requireNonNull(interfaceC0318d, "factory == null");
+            this.callFactory = interfaceC0318d;
+            return this;
+        }
+
+        public Builder callbackExecutor(Executor executor) {
+            Objects.requireNonNull(executor, "executor == null");
+            this.callbackExecutor = executor;
+            return this;
+        }
+
+        public Builder client(F f2) {
+            Objects.requireNonNull(f2, "client == null");
+            return callFactory(f2);
+        }
+
+        public List<Converter.Factory> converterFactories() {
+            return this.converterFactories;
+        }
+
+        public Builder validateEagerly(boolean z3) {
+            this.validateEagerly = z3;
+            return this;
+        }
+
+        public Builder() {
+            this(Platform.get());
+        }
+
+        public Builder(Retrofit retrofit) {
+            this.converterFactories = new ArrayList();
+            this.callAdapterFactories = new ArrayList();
+            Platform platform = Platform.get();
+            this.platform = platform;
+            this.callFactory = retrofit.callFactory;
+            this.baseUrl = retrofit.baseUrl;
+            int size = retrofit.converterFactories.size() - platform.defaultConverterFactoriesSize();
+            for (int i = 1; i < size; i++) {
+                this.converterFactories.add(retrofit.converterFactories.get(i));
+            }
+            int size2 = retrofit.callAdapterFactories.size() - this.platform.defaultCallAdapterFactoriesSize();
+            for (int i4 = 0; i4 < size2; i4++) {
+                this.callAdapterFactories.add(retrofit.callAdapterFactories.get(i4));
+            }
+            this.callbackExecutor = retrofit.callbackExecutor;
+            this.validateEagerly = retrofit.validateEagerly;
+        }
+
+        public Builder baseUrl(String str) {
+            Objects.requireNonNull(str, "baseUrl == null");
+            Intrinsics.checkNotNullParameter(str, "<this>");
+            C0335v c0335v = new C0335v();
+            c0335v.d(null, str);
+            return baseUrl(c0335v.a());
+        }
+
+        public Builder baseUrl(w wVar) {
+            Objects.requireNonNull(wVar, "baseUrl == null");
+            if ("".equals(wVar.f6418f.get(r0.size() - 1))) {
+                this.baseUrl = wVar;
+                return this;
+            }
+            throw new IllegalArgumentException("baseUrl must end in /: " + wVar);
+        }
+    }
+}

apk_decompiled/sources/retrofit2/ServiceMethod.java

@@ -0,0 +1,21 @@
+package retrofit2;
+
+import java.lang.reflect.Method;
+import java.lang.reflect.Type;
+
+/* loaded from: classes3.dex */
+abstract class ServiceMethod<T> {
+    public static <T> ServiceMethod<T> parseAnnotations(Retrofit retrofit, Method method) {
+        RequestFactory parseAnnotations = RequestFactory.parseAnnotations(retrofit, method);
+        Type genericReturnType = method.getGenericReturnType();
+        if (Utils.hasUnresolvableType(genericReturnType)) {
+            throw Utils.methodError(method, "Method return type must not include a type variable or wildcard: %s", genericReturnType);
+        }
+        if (genericReturnType != Void.TYPE) {
+            return HttpServiceMethod.parseAnnotations(retrofit, method, parseAnnotations);
+        }
+        throw Utils.methodError(method, "Service methods cannot return void.", new Object[0]);
+    }
+
+    public abstract T invoke(Object[] objArr);
+}

apk_decompiled/sources/retrofit2/SkipCallbackExecutor.java

@@ -0,0 +1,14 @@
+package retrofit2;
+
+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: classes3.dex */
+public @interface SkipCallbackExecutor {
+}

apk_decompiled/sources/retrofit2/SkipCallbackExecutorImpl.java

@@ -0,0 +1,38 @@
+package retrofit2;
+
+import java.lang.annotation.Annotation;
+
+/* loaded from: classes3.dex */
+final class SkipCallbackExecutorImpl implements SkipCallbackExecutor {
+    private static final SkipCallbackExecutor INSTANCE = new SkipCallbackExecutorImpl();
+
+    public static Annotation[] ensurePresent(Annotation[] annotationArr) {
+        if (Utils.isAnnotationPresent(annotationArr, SkipCallbackExecutor.class)) {
+            return annotationArr;
+        }
+        Annotation[] annotationArr2 = new Annotation[annotationArr.length + 1];
+        annotationArr2[0] = INSTANCE;
+        System.arraycopy(annotationArr, 0, annotationArr2, 1, annotationArr.length);
+        return annotationArr2;
+    }
+
+    @Override // java.lang.annotation.Annotation
+    public Class<? extends Annotation> annotationType() {
+        return SkipCallbackExecutor.class;
+    }
+
+    @Override // java.lang.annotation.Annotation
+    public boolean equals(Object obj) {
+        return obj instanceof SkipCallbackExecutor;
+    }
+
+    @Override // java.lang.annotation.Annotation
+    public int hashCode() {
+        return 0;
+    }
+
+    @Override // java.lang.annotation.Annotation
+    public String toString() {
+        return "@" + SkipCallbackExecutor.class.getName() + "()";
+    }
+}

apk_decompiled/sources/retrofit2/Utils.java

@@ -0,0 +1,467 @@
+package retrofit2;
+
+import C.w;
+import e3.T;
+import java.io.IOException;
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Array;
+import java.lang.reflect.GenericArrayType;
+import java.lang.reflect.Method;
+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 java.util.Objects;
+import r3.InterfaceC0578j;
+
+/* loaded from: classes3.dex */
+final class Utils {
+    static final Type[] EMPTY_TYPE_ARRAY = new Type[0];
+
+    /* loaded from: classes3.dex */
+    public static final class GenericArrayTypeImpl implements GenericArrayType {
+        private final Type componentType;
+
+        public 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 w.r(new StringBuilder(), Utils.typeToString(this.componentType), "[]");
+        }
+    }
+
+    /* loaded from: classes3.dex */
+    public static final class ParameterizedTypeImpl implements ParameterizedType {
+        private final Type ownerType;
+        private final Type rawType;
+        private final Type[] typeArguments;
+
+        public 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) {
+                Objects.requireNonNull(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 (type != null ? type.hashCode() : 0) ^ hashCode;
+        }
+
+        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();
+        }
+    }
+
+    /* loaded from: classes3.dex */
+    public static final class WildcardTypeImpl implements WildcardType {
+        private final Type lowerBound;
+        private final Type upperBound;
+
+        public WildcardTypeImpl(Type[] typeArr, Type[] typeArr2) {
+            if (typeArr2.length > 1) {
+                throw new IllegalArgumentException();
+            }
+            if (typeArr.length != 1) {
+                throw new IllegalArgumentException();
+            }
+            if (typeArr2.length != 1) {
+                typeArr[0].getClass();
+                Utils.checkNotPrimitive(typeArr[0]);
+                this.lowerBound = null;
+                this.upperBound = typeArr[0];
+                return;
+            }
+            typeArr2[0].getClass();
+            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 (this.upperBound.hashCode() + 31) ^ (type != null ? type.hashCode() + 31 : 1);
+        }
+
+        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() {
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    /* JADX WARN: Type inference failed for: r0v0, types: [r3.i, r3.j, java.lang.Object] */
+    public static T buffer(T t2) throws IOException {
+        ?? obj = new Object();
+        t2.source().U(obj);
+        return T.create(t2.contentType(), t2.contentLength(), (InterfaceC0578j) obj);
+    }
+
+    public 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;
+    }
+
+    public 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());
+    }
+
+    public 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++) {
+                Class<?> cls3 = interfaces[i];
+                if (cls3 == cls2) {
+                    return cls.getGenericInterfaces()[i];
+                }
+                if (cls2.isAssignableFrom(cls3)) {
+                    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;
+    }
+
+    public static Type getParameterLowerBound(int i, ParameterizedType parameterizedType) {
+        Type type = parameterizedType.getActualTypeArguments()[i];
+        return type instanceof WildcardType ? ((WildcardType) type).getLowerBounds()[0] : type;
+    }
+
+    public 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;
+        }
+        StringBuilder t2 = w.t(i, "Index ", " not in range [0,");
+        t2.append(actualTypeArguments.length);
+        t2.append(") for ");
+        t2.append(parameterizedType);
+        throw new IllegalArgumentException(t2.toString());
+    }
+
+    public static Class<?> getRawType(Type type) {
+        Objects.requireNonNull(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());
+    }
+
+    public static Type getSupertype(Type type, Class<?> cls, Class<?> cls2) {
+        if (cls2.isAssignableFrom(cls)) {
+            return resolve(type, cls, getGenericSupertype(type, cls, cls2));
+        }
+        throw new IllegalArgumentException();
+    }
+
+    public 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();
+    }
+
+    public static boolean isAnnotationPresent(Annotation[] annotationArr, Class<? extends Annotation> cls) {
+        for (Annotation annotation : annotationArr) {
+            if (cls.isInstance(annotation)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public static RuntimeException methodError(Method method, String str, Object... objArr) {
+        return methodError(method, null, str, objArr);
+    }
+
+    public static RuntimeException parameterError(Method method, Throwable th, int i, String str, Object... objArr) {
+        return methodError(method, th, str + " (parameter #" + (i + 1) + ")", objArr);
+    }
+
+    public 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 z3 = 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 (!z3) {
+                        actualTypeArguments = (Type[]) actualTypeArguments.clone();
+                        z3 = true;
+                    }
+                    actualTypeArguments[i] = resolve4;
+                }
+            }
+            return z3 ? new ParameterizedTypeImpl(resolve3, parameterizedType.getRawType(), actualTypeArguments) : parameterizedType;
+        }
+        boolean z4 = type3 instanceof WildcardType;
+        Type type4 = type3;
+        if (z4) {
+            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) {
+            Type genericSupertype = getGenericSupertype(type, cls, declaringClassOf);
+            if (genericSupertype instanceof ParameterizedType) {
+                return ((ParameterizedType) genericSupertype).getActualTypeArguments()[indexOf(declaringClassOf.getTypeParameters(), typeVariable)];
+            }
+        }
+        return typeVariable;
+    }
+
+    public 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);
+        }
+    }
+
+    public static String typeToString(Type type) {
+        return type instanceof Class ? ((Class) type).getName() : type.toString();
+    }
+
+    public static RuntimeException methodError(Method method, Throwable th, String str, Object... objArr) {
+        return new IllegalArgumentException(String.format(str, objArr) + "\n    for method " + method.getDeclaringClass().getSimpleName() + "." + method.getName(), th);
+    }
+
+    public static RuntimeException parameterError(Method method, int i, String str, Object... objArr) {
+        return methodError(method, str + " (parameter #" + (i + 1) + ")", objArr);
+    }
+}

apk_decompiled/sources/retrofit2/a.java

@@ -0,0 +1,38 @@
+package retrofit2;
+
+import retrofit2.DefaultCallAdapterFactory;
+
+/* loaded from: classes3.dex */
+public final /* synthetic */ class a implements Runnable {
+
+    /* renamed from: a, reason: collision with root package name */
+    public final /* synthetic */ int f8323a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public final /* synthetic */ DefaultCallAdapterFactory.ExecutorCallbackCall.AnonymousClass1 f8324b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public final /* synthetic */ Callback f8325c;
+
+    /* renamed from: d, reason: collision with root package name */
+    public final /* synthetic */ Object f8326d;
+
+    public /* synthetic */ a(DefaultCallAdapterFactory.ExecutorCallbackCall.AnonymousClass1 anonymousClass1, Callback callback, Object obj, int i) {
+        this.f8323a = i;
+        this.f8324b = anonymousClass1;
+        this.f8325c = callback;
+        this.f8326d = obj;
+    }
+
+    @Override // java.lang.Runnable
+    public final void run() {
+        switch (this.f8323a) {
+            case 0:
+                DefaultCallAdapterFactory.ExecutorCallbackCall.AnonymousClass1.b(this.f8324b, this.f8325c, (Response) this.f8326d);
+                return;
+            default:
+                DefaultCallAdapterFactory.ExecutorCallbackCall.AnonymousClass1.a(this.f8324b, this.f8325c, (Throwable) this.f8326d);
+                return;
+        }
+    }
+}

apk_decompiled/sources/retrofit2/converter/moshi/MoshiConverterFactory.java

@@ -0,0 +1,96 @@
+package retrofit2.converter.moshi;
+
+import Z2.AbstractC0104l;
+import Z2.D;
+import Z2.G;
+import Z2.o;
+import e3.M;
+import e3.T;
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Type;
+import java.util.Collections;
+import java.util.LinkedHashSet;
+import java.util.Set;
+import retrofit2.Converter;
+import retrofit2.Retrofit;
+
+/* loaded from: classes3.dex */
+public final class MoshiConverterFactory extends Converter.Factory {
+    private final boolean failOnUnknown;
+    private final boolean lenient;
+    private final G moshi;
+    private final boolean serializeNulls;
+
+    private MoshiConverterFactory(G g4, boolean z3, boolean z4, boolean z5) {
+        this.moshi = g4;
+        this.lenient = z3;
+        this.failOnUnknown = z4;
+        this.serializeNulls = z5;
+    }
+
+    public static MoshiConverterFactory create() {
+        return create(new G(new D()));
+    }
+
+    private static Set<? extends Annotation> jsonAnnotations(Annotation[] annotationArr) {
+        LinkedHashSet linkedHashSet = null;
+        for (Annotation annotation : annotationArr) {
+            if (annotation.annotationType().isAnnotationPresent(o.class)) {
+                if (linkedHashSet == null) {
+                    linkedHashSet = new LinkedHashSet();
+                }
+                linkedHashSet.add(annotation);
+            }
+        }
+        return linkedHashSet != null ? Collections.unmodifiableSet(linkedHashSet) : Collections.EMPTY_SET;
+    }
+
+    public MoshiConverterFactory asLenient() {
+        return new MoshiConverterFactory(this.moshi, true, this.failOnUnknown, this.serializeNulls);
+    }
+
+    public MoshiConverterFactory failOnUnknown() {
+        return new MoshiConverterFactory(this.moshi, this.lenient, true, this.serializeNulls);
+    }
+
+    @Override // retrofit2.Converter.Factory
+    public Converter<?, M> requestBodyConverter(Type type, Annotation[] annotationArr, Annotation[] annotationArr2, Retrofit retrofit) {
+        AbstractC0104l c4 = this.moshi.c(type, jsonAnnotations(annotationArr), null);
+        if (this.lenient) {
+            c4 = c4.lenient();
+        }
+        if (this.failOnUnknown) {
+            c4 = c4.failOnUnknown();
+        }
+        if (this.serializeNulls) {
+            c4 = c4.serializeNulls();
+        }
+        return new MoshiRequestBodyConverter(c4);
+    }
+
+    @Override // retrofit2.Converter.Factory
+    public Converter<T, ?> responseBodyConverter(Type type, Annotation[] annotationArr, Retrofit retrofit) {
+        AbstractC0104l c4 = this.moshi.c(type, jsonAnnotations(annotationArr), null);
+        if (this.lenient) {
+            c4 = c4.lenient();
+        }
+        if (this.failOnUnknown) {
+            c4 = c4.failOnUnknown();
+        }
+        if (this.serializeNulls) {
+            c4 = c4.serializeNulls();
+        }
+        return new MoshiResponseBodyConverter(c4);
+    }
+
+    public MoshiConverterFactory withNullSerialization() {
+        return new MoshiConverterFactory(this.moshi, this.lenient, this.failOnUnknown, true);
+    }
+
+    public static MoshiConverterFactory create(G g4) {
+        if (g4 != null) {
+            return new MoshiConverterFactory(g4, false, false, false);
+        }
+        throw new NullPointerException("moshi == null");
+    }
+}

apk_decompiled/sources/retrofit2/converter/moshi/MoshiRequestBodyConverter.java

@@ -0,0 +1,40 @@
+package retrofit2.converter.moshi;
+
+import Z2.AbstractC0104l;
+import Z2.t;
+import e3.A;
+import e3.M;
+import e3.z;
+import java.io.IOException;
+import java.util.regex.Pattern;
+import retrofit2.Converter;
+
+/* loaded from: classes3.dex */
+final class MoshiRequestBodyConverter<T> implements Converter<T, M> {
+    private static final A MEDIA_TYPE;
+    private final AbstractC0104l adapter;
+
+    static {
+        Pattern pattern = A.f6197d;
+        MEDIA_TYPE = z.a("application/json; charset=UTF-8");
+    }
+
+    public MoshiRequestBodyConverter(AbstractC0104l abstractC0104l) {
+        this.adapter = abstractC0104l;
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    @Override // retrofit2.Converter
+    public /* bridge */ /* synthetic */ M convert(Object obj) throws IOException {
+        return convert((MoshiRequestBodyConverter<T>) obj);
+    }
+
+    /* JADX WARN: Can't rename method to resolve collision */
+    /* JADX WARN: Type inference failed for: r0v0, types: [r3.i, java.lang.Object, r3.h] */
+    @Override // retrofit2.Converter
+    public M convert(T t2) throws IOException {
+        ?? obj = new Object();
+        this.adapter.toJson(new t(obj), t2);
+        return M.create(MEDIA_TYPE, obj.h(obj.f8284b));
+    }
+}

apk_decompiled/sources/retrofit2/converter/moshi/MoshiResponseBodyConverter.java

@@ -0,0 +1,46 @@
+package retrofit2.converter.moshi;
+
+import Z2.AbstractC0104l;
+import Z2.q;
+import Z2.s;
+import e3.T;
+import f0.C0338b;
+import java.io.IOException;
+import r3.C0579k;
+import r3.InterfaceC0578j;
+import retrofit2.Converter;
+
+/* loaded from: classes3.dex */
+final class MoshiResponseBodyConverter<T> implements Converter<T, T> {
+    private static final C0579k UTF8_BOM;
+    private final AbstractC0104l adapter;
+
+    static {
+        C0579k c0579k = C0579k.f8285d;
+        UTF8_BOM = C0338b.m("EFBBBF");
+    }
+
+    public MoshiResponseBodyConverter(AbstractC0104l abstractC0104l) {
+        this.adapter = abstractC0104l;
+    }
+
+    @Override // retrofit2.Converter
+    public T convert(T t2) throws IOException {
+        InterfaceC0578j source = t2.source();
+        try {
+            if (source.H(UTF8_BOM)) {
+                source.l(r1.d());
+            }
+            s sVar = new s(source);
+            T t4 = (T) this.adapter.fromJson(sVar);
+            if (sVar.f0() == q.f2278j) {
+                t2.close();
+                return t4;
+            }
+            throw new RuntimeException("JSON document was not fully consumed.");
+        } catch (Throwable th) {
+            t2.close();
+            throw th;
+        }
+    }
+}

apk_decompiled/sources/retrofit2/converter/moshi/package-info.java

@@ -0,0 +1,5 @@
+@EverythingIsNonNull
+package retrofit2.converter.moshi;
+
+import retrofit2.internal.EverythingIsNonNull;
+

apk_decompiled/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: classes3.dex */
+public @interface Body {
+}

apk_decompiled/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: classes3.dex */
+public @interface DELETE {
+    String value() default "";
+}

apk_decompiled/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: classes3.dex */
+public @interface Field {
+    boolean encoded() default false;
+
+    String value();
+}

apk_decompiled/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: classes3.dex */
+public @interface FieldMap {
+    boolean encoded() default false;
+}

apk_decompiled/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: classes3.dex */
+public @interface FormUrlEncoded {
+}

apk_decompiled/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: classes3.dex */
+public @interface GET {
+    String value() default "";
+}

apk_decompiled/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: classes3.dex */
+public @interface HEAD {
+    String value() default "";
+}

apk_decompiled/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: classes3.dex */
+public @interface HTTP {
+    boolean hasBody() default false;
+
+    String method();
+
+    String path() default "";
+}

apk_decompiled/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: classes3.dex */
+public @interface Header {
+    String value();
+}

apk_decompiled/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: classes3.dex */
+public @interface HeaderMap {
+}

apk_decompiled/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: classes3.dex */
+public @interface Headers {
+    String[] value();
+}

apk_decompiled/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: classes3.dex */
+public @interface Multipart {
+}

apk_decompiled/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: classes3.dex */
+public @interface OPTIONS {
+    String value() default "";
+}

apk_decompiled/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: classes3.dex */
+public @interface PATCH {
+    String value() default "";
+}

apk_decompiled/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: classes3.dex */
+public @interface POST {
+    String value() default "";
+}

apk_decompiled/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: classes3.dex */
+public @interface PUT {
+    String value() default "";
+}

apk_decompiled/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: classes3.dex */
+public @interface Part {
+    String encoding() default "binary";
+
+    String value() default "";
+}

apk_decompiled/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: classes3.dex */
+public @interface PartMap {
+    String encoding() default "binary";
+}

apk_decompiled/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: classes3.dex */
+public @interface Path {
+    boolean encoded() default false;
+
+    String value();
+}

apk_decompiled/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: classes3.dex */
+public @interface Query {
+    boolean encoded() default false;
+
+    String value();
+}

apk_decompiled/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: classes3.dex */
+public @interface QueryMap {
+    boolean encoded() default false;
+}

apk_decompiled/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: classes3.dex */
+public @interface QueryName {
+    boolean encoded() default false;
+}

apk_decompiled/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: classes3.dex */
+public @interface Streaming {
+}

apk_decompiled/sources/retrofit2/http/Tag.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: classes3.dex */
+public @interface Tag {
+}

apk_decompiled/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: classes3.dex */
+public @interface Url {
+}

apk_decompiled/sources/retrofit2/internal/EverythingIsNonNull.java

@@ -0,0 +1,11 @@
+package retrofit2.internal;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+@Documented
+@Retention(RetentionPolicy.RUNTIME)
+/* loaded from: classes3.dex */
+public @interface EverythingIsNonNull {
+}

apk_decompiled/sources/retrofit2/package-info.java

@@ -0,0 +1,5 @@
+@EverythingIsNonNull
+package retrofit2;
+
+import retrofit2.internal.EverythingIsNonNull;
+