RxJavaBackwardCompatibility.java

public class RxBackwardCompatibility {

    public static <T> rx.Observable<T> toOne(final io.reactivex.Observable<T> observable) {
        return rx.Observable.create(new rx.Observable.OnSubscribe<T>() {
            @Override
            public void call(final rx.Subscriber<? super T> subscriber) {
                observable.subscribe(new io.reactivex.Observer<T>() {
                    @Override
                    public void onSubscribe(io.reactivex.disposables.Disposable d) {
                        // TODO
                    }

                    @Override
                    public void onNext(T value) {
                        subscriber.onNext(value);
                    }

                    @Override
                    public void onError(Throwable e) {
                        subscriber.onError(e);
                    }

                    @Override
                    public void onComplete() {
                        subscriber.onCompleted();
                    }
                });
            }
        });
    }

    public static <T> rx.Single<T> toOne(final io.reactivex.Single<T> single) {
        return rx.Single.create(new rx.Single.OnSubscribe<T>() {
            @Override
            public void call(final rx.SingleSubscriber<? super T> singleSubscriber) {
                single.subscribe(new io.reactivex.SingleObserver<T>() {
                    @Override
                    public void onSubscribe(io.reactivex.disposables.Disposable d) {
                        // TODO
                    }

                    @Override
                    public void onSuccess(T value) {
                        singleSubscriber.onSuccess(value);
                    }

                    @Override
                    public void onError(Throwable e) {
                        singleSubscriber.onError(e);
                    }
                });
            }
        });
    }
}