Quiero crear un Observable desde el oyente de clics de vista usando RxJava 2. Comencé desde la implementación más simple (no uso lambdas aquí para mostrarle diferentes tipos en este método):
Observable<View> viewObservable = Observable.create(new ObservableOnSubscribe<View>() { @Override public void subscribe(@NonNull ObservableEmitter<View> e) throws Exception { mNewWordView.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View value) { if (!e.isDisposed()) { e.onNext(value); } } }); } }); Luego pensé en la forma de establecer onClickListener en nulo si no se necesita más. Descubrí que hay dos métodos con nombres similares (en cuanto a mí):
e.setCancellable(Cancellable c); y e.setDisposable(Disposable d);
¿Cuál es la diferencia entre ellos y cuál debo usar?
Del Javadoc :
[
Cancellablees] Una interfaz funcional que tiene un único método de cancelación que puede lanzar.
Disposable no es una interfaz funcional y, además, cuando implementa su método dispose() , no se le permite generar excepciones marcadas.
Por el contrario, muchos componentes que no son RxJava devuelven un Closeable o AutoCloseable que se definen a través de throws IOException y throws Exception y son un poco una carga porque necesitarías intentar atraparlo.
Por ejemplo, querrá usar setCancellable cuando trabaje con un archivo:
Observable.create((ObservableEmitter<byte[]> e) -> { FileInputStream fin = new FileInputStream("raw.dat"); e.setCancellable(fin::close); byte[] buffer = new byte[4096]; for (;;) { int r = fin.read(buffer); if (r < 0) { break; } e.onNext(buffer); } e.onComplete(); }); y usaría setDisposable si usa un Scheduler :
Observable.create((ObservableEmitter<Event> e) -> { Worker worker = Schedulers.io().createWorker(); e.setDisposable(worker); eventSource.onEvent(es -> worker.schedule(() -> e.onNext(es)) ); });El Cancellable termina siendo envuelto en un Disposable , por lo que el efecto final es el mismo para cualquiera de las llamadas. La diferencia es que Disposable tiene más funciones que quizás no desee implementar, por lo que la sencilla interfaz Cancellable está ahí como alternativa.
Si solo desea deshacerse de algo cuando finalice el observable, use Cancellable . Si tiene un recurso que podría desecharse debido a algún motivo externo, desea implementar Disposable para implementar el método Disposable.isDisposed() .
Tenga en cuenta que los métodos son mutuamente excluyentes. Solo se puede registrar un solo desechable o cancelable a la vez. Llamar a ambos sobrescribe el primero.