android - tinder - pantalla cancelar suscripcion

Cuándo cancelar la suscripción de una suscripción

Question

Tengo una pregunta sobre cómo cancelar la suscripción de un observable. Tengo dos códigos y no estoy muy seguro de cuál es mejor.

Ejemplo 1 -> Anular la suscripción del suscriptor una vez que la secuencia haya finalizado:

Subscriber<String> subscriber = new Subscriber<String>() {
@Override
public void onCompleted() {
progressdialog.dissmiss();
unsubscribe();
}
@Override
public void onError(Throwable e) {
progressdialog.dissmiss();
}
@Override
public void onNext(String s) {
// do something with data
}
}

Ejemplo 2 -> Anular la suscripción de la suscripción una vez que se destruye la actividad:

private void test(){
Subscriber<String> subscriber = new Subscriber<String>() {
@Override
public void onCompleted() {
progressdialog.dissmiss();
}
@Override
public void onError(Throwable e) {
progressdialog.dissmiss();
}
@Override
public void onNext(String s) {
// do something with data
}
};
subscription = BackendRequest.login(loginRequest)
.subscribeOn(Schedulers.newThread())
.observeOn(AndroidSchedulers.mainThread())
.subscribe(subscriber);
compositeSubscription.add(subscription);
}
@Override
protected void onDestroy() {
super.onDestroy();
this.subscription.unsubscribe();
}

Tengo que mencionar que mis observables solo emitirán una vez, la actividad no debe esperar más llamadas del Observable.

¿Cuál es mejor?

Gracias por adelantado

Answer 1

Creo que eso depende de tus necesidades. Si la actividad no espera otras llamadas, supongo que podría darse de baja en onCompleted ().

Siempre doy de baja en onDestroy ()

@Override
protected void onDestroy() {
super.onDestroy();
if (subscription != null) {
subscription.unsubscribe();
}
}

EDITAR: eche un vistazo a http://reactivex.io/RxJava/javadoc/rx/subscriptions/CompositeSubscription.html

private CompositeSubscription mCompositeSubscription = new CompositeSubscription();
private void doSomething() {
mCompositeSubscription.add(
AndroidObservable.bindActivity(this, Observable.just("Hello, World!"))
.subscribe(s -> System.out.println(s)));
}
@Override
protected void onDestroy() {
super.onDestroy();
mCompositeSubscription.unsubscribe();
}

Answer 2

De las dos opciones, la segunda es mejor.

En su primer ejemplo, está onComplete() la unsubscribing en el método onComplete() que no es necesario. Si llega al onComplete() de una Suscripción, ya no tiene la responsabilidad de onComplete() su suscripción.

Tu segundo ejemplo es el correcto. La idea detrás de CompositeSubscription es que puede agregarle múltiples Subscriptions y luego limpiarlas ( unsubscribe ) a la vez. En otras palabras, esto le ahorra la necesidad de mantener una lista de las Subscriptions que necesita darse de baja.

Una parte complicada de usar CompositeSubscription es que si una vez se da de unsubscribe , NO puede volver a usarla. Puede consultar la documentación del método compositeSubscription.add() para obtener más información sobre por qué. En resumen, cancelará directamente la suscripción que está intentando agregar. Esa ha sido una decisión deliberada (puedes leer más sobre esto HERE ).

Volviendo a su ejemplo, llamar a unsubscribe() en onDestroy() de la Actividad está bien y lo salvará de las pérdidas de memoria. Con respecto a su comentario de que ocurren problemas cuando llama al método test() varias veces, diría que su problema está en otra parte. Tal vez su caso de uso no debería permitirlo llamar varias veces, tal vez debería limpiar los datos antiguos antes de usar el que acaba de recibir, etc. Tal vez si ha explicado en detalle a qué tipo de problemas se enfrenta, podríamos ayudarlo más. Pero en lo que respecta a CompositeSubscription : ¡lo está utilizando y cancelando su suscripción correctamente!

Answer 3

No es necesario darse de baja en onCompleted . Echa un vistazo a El contrato observable

Cuando un Observable emite una notificación OnError o OnComplete a sus observadores, esto finaliza la suscripción. Los observadores no necesitan emitir una notificación de cancelación de suscripción para finalizar las suscripciones que finaliza el observable de esta manera.

Por otro lado, definitivamente debe cancelar la suscripción en onDestroy para evitar pérdidas de memoria.