Convert from `ObservableEmitter` to `Observer` in rx-java2 - rx-java2

Question

Is there a easy way to convert from io.reactivex.ObservableEmitter<T>to io.reactivex.Observer<T>? I could not find function to do that in rx-java2 library.
The implementation seems to be trivial:
public static <T> Observer<T> toObserver(ObservableEmitter<T> oe) {
return new Observer<T>() {
#Override
public void onSubscribe(Disposable d) {
oe.setDisposable(d);
}
#Override
public void onNext(T t) {
oe.onNext(t);
}
#Override
public void onError(Throwable e) {
oe.onError(e);
}
#Override
public void onComplete() {
oe.onComplete();
}
};
}
but it feels that it should be part of standard library implementation, as it provides transformation between two core types in rx-java2.
Basically I am trying to migrate following code from rxjava 1 to 2
class X<T, O1, O2> implements Transformer<T, Either<O1, O2>> {
Transformer<T, O1> t1;
Transformer<T, O2> t2;
#Override
public Observable<Either<O1, O2>> call(Observable<T> input) {
return input.flatMap(new Func1<T, Observable<Either<O1, O2>>>() {
#Override
public Observable<Either<O1, O2>> call(final T t) {
return Observable.<Either<O1, O2>>create(new OnSubscribe<Either<O1, O2>>() {
#Override
public void call(final Subscriber<? super Either<O1, O2>> sub) {
t1.call(Observable.just(t)).map(o1 -> Either.<O1, O2>left(o1)).subscribe(sub);
t2.call(Observable.just(t)).map(o2 -> Either.<O1, O2>right(o2)).subscribe(sub);
}
});
}
});
}
}
Notice that OnSubscribe provides Subscriber interface which I can then use to subscribe to two other Observable's, with rxjava 2 conversion is needed.

Answer 1

Looks like you need publish(Function):
(Your code looks convoluted and was violating the protocol in v1 by the way).
ObservableTransformer<T, O1> t1 = ...
ObservableTransformer<T, O2> t2 = ...
ObservableTransformer<T, Either<O1, O2>> combiner = o ->
o.publish(g -> Observable.merge(
t1.apply(g).map(o1 -> Either.<O1, O2>left(o1)),
t2.apply(g).map(o2 -> Either.<O1, O2>right(o2))
));
If you really want to stick to the outer flatMap (in case the inners go async), use merge() instead of create:
return input.flatMap(new Func1<T, Observable<Either<O1, O2>>>() {
#Override
public Observable<Either<O1, O2>> call(final T t) {
Observable<T> just = Observable.just(t);
Observable.merge(
t1.call(just).map(o1 -> Either.<O1, O2>left(o1)),
t2.call(just).map(o2 -> Either.<O1, O2>right(o2))
)
}
});