Observable which does not pass anything in onNext()

Question

I would need an Observable, for example to provide a system clock, which does not need to pass anything in onNext(). I couldn\'t find a signature that would allow me to do that.

Answer 1

I don't know this will helps you or not.
The code written in RxSwift.

// Create an observable and emit somethings
let myObservable = Observable<Void>.create{ observer in
    observer.on(.next(Void()))
    return Disposables.create()
}

// Observer subscribe changes
myObservable.subscribe(onNext: {
    _ in
    print("Hello")
}).disposed(by: disposeBag)

Or use the Variable object

// Create a Variable object that contanins nothing
var myValueWatcher:Variable<Void> = Variable<Void>(Void())

// Observer subscribe changes
myValueWatcher.asObservable().skip(1).subscribe(onNext: {
    _ in
    print("Changes!")
}).disposed(by: disposeBag)


// The emit code
myValueWatcher.value = Void()

Answer 2

If you need something to be passed to onNext() before onCompleted() is called:

Observable.<Void>just(null)

If you only need onCompleted() to be called:

Observable.empty()

Answer 3

You don't need to call onNext if your Observable doesn't emit anything. You could use Void in your signature and do something like

Observable<Void> o = Observable.create(new Observable.OnSubscribe<Void>() {
    @Override
    public void call(Subscriber<? super Void> subscriber) {
        // Do the work and call onCompleted when you done,
        // no need to call onNext if you have nothing to emit
        subscriber.onCompleted();
    }
});

o.subscribe(new OnCompletedObserver<Void>() {
    @Override
    public void onCompleted() {
        System.out.println("onCompleted");
    }

    @Override
    public void onError(Throwable e) {
        System.out.println("onError " + e.getMessage());
    }
});

You can define an OnCompletedObserver to simplify your Observer callback so that you don't have to override the onNext since you don't need it.

public abstract class OnCompletedObserver<T> implements Observer<T> {
    @Override
    public void onNext(T o) {

    }
}

If I've understood what you're asking then this should do the trick.

Answer 4

RxJava 2 Wiki:

RxJava 2.x no longer accepts null values and the following will yield NullPointerException immediately or as a signal to downstream.

...

This means that Observable<Void> can no longer emit any values but only terminate normally or with an exception. API designers may instead choose to define Observable<Object> with no guarantee on what Object will be (which should be irrelevant anyway)

It means that you can't use Void and do Observable.just(null).

Use Object or some other simple type instead:

Observable.just(new Object());

Answer 5

Starting with RxJava 2, the propper way to do this is to use a Completable

From the docs:

Represents a deferred computation without any value but only indication for completion or exception. The class follows a similar event pattern as Reactive-Streams: onSubscribe (onError|onComplete)?

Answer 6

One of the light solutions is to use Observable<Boolean>

And then onNext(Boolean.TRUE) which you then just ignore.

But probably you shouldn't use Observable in that case.
Consider using Completable instead