rxjava2 - rxjava dispose

¿Cuál es la diferencia entre RxJava 2 Cancelable y Desechable?

Question

Quiero crear un Observable desde la vista, haga clic en el oyente 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. Encontré que hay dos métodos con nombres similares (como para mí):

e.setCancellable(Cancellable c); y e.setDisposable(Disposable d);

¿Cuál es la diferencia entre ellos y cuál debo usar?

Answer 1

Desde el Javadoc :

[ Cancellable es] Una interfaz funcional que tiene un solo método de cancelación que puede lanzar.

El Disposable no es una interfaz funcional más cuando implementa su método dispose() , no se le permite lanzar excepciones marcadas.

Por el contrario, muchos componentes que no son RxJava devuelven un objeto Closeable o AutoCloseable que se define a través de la throws IOException y la throws Exception y son un poco pesados ​​porque necesitaría intentarlo.

Por ejemplo, querría usar setCancellable cuando trabaja 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 usara un Scheduler :

Observable.create((ObservableEmitter<Event> e) -> {
    Worker worker = Schedulers.io().createWorker();
    e.setDisposable(worker);

    eventSource.onEvent(es ->
        worker.schedule(() -> e.onNext(es))
    );
});

Answer 2

El Cancellable termina 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 es posible que no desee implementar, por lo que la sencilla interfaz Cancellable está ahí como alternativa.

Si solo desea disponer de algo cuando lo observable termine use Cancellable . Si tiene un recurso que podría eliminarse 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. Llamando a ambos sobrescribe el primero.