Osservabile che non passa nulla in onNext()

Question

Avrei bisogno di un Osservabile, ad esempio per fornire un orologio di sistema, che non ha bisogno di passare nulla in onNext(). Non sono riuscito a trovare una firma che mi permettesse di farlo.

Certo, potrei usare qualsiasi oggetto e quindi passare null, ma questo non ha molto senso. Quindi la mia domanda è se c'è un modo migliore per farlo.

Observable.create(new Observable.OnSubscribe<Anyobject>() { // use any object in the signature 

      @Override public void call(Subscriber<? super Anyobject> subscriber) { 

        subscriber.onNext(null); // then pass null 
        subscriber.onCompleted(); 

      } 

     }) 

Answer 1

Non è necessario chiamare onNext se il Observable non emette nulla. Si potrebbe utilizzare Void nella tua firma e fare qualcosa di simile

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()); 
    } 
}); 

È possibile definire un OnCompletedObserver per semplificare il callback Observer in modo che non si deve ignorare l'onNext dal momento che non ne hai bisogno.

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

    } 
} 

Se ho capito cosa stai chiedendo, questo dovrebbe fare il trucco.

Answer 2

Se avete bisogno di qualcosa da passare al onNext() prima onCompleted() si chiama:

Observable.<Void>just(null) 

Se solo bisogno onCompleted() di essere chiamato:

Observable.empty() 

Answer 3

Non so questa volontà ti aiuta o no.
Il codice scritto 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) 

Oppure utilizzare l'oggetto variabile

// 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 4

RxJava 2 Wiki:

RxJava 2.x non accetta valori nulli e la seguente produrrà immediatamente o come segnale a valle NullPointerException .

...

Ciò significa che Observable<Void> può più emettere alcun valore ma solo terminare normalmente o con un'eccezione. API progettisti possono invece scegliere di definire Observable<Object> senza alcuna garanzia su quello che sarà Object (che dovrebbe essere comunque irrilevante)

Ciò significa che non è possibile utilizzare Void e fare Observable.just(null).

Usa Object o qualche altro tipo semplice invece:

Observable.just(new Object());