Initial commit

sources/retrofit2/adapter/rxjava2/BodyObservable.java

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

sources/retrofit2/adapter/rxjava2/CallEnqueueObservable.java

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

sources/retrofit2/adapter/rxjava2/CallExecuteObservable.java

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

sources/retrofit2/adapter/rxjava2/HttpException.java

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

sources/retrofit2/adapter/rxjava2/Result.java

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

sources/retrofit2/adapter/rxjava2/ResultObservable.java

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

sources/retrofit2/adapter/rxjava2/RxJava2CallAdapter.java

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

sources/retrofit2/adapter/rxjava2/RxJava2CallAdapterFactory.java

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

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

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