Quels mécanismes peuvent être utilisés pour annuler les requêtes du presenter vers la vue?

• Vue morte: Le présentateur ne conserve pas de référence directe à la vue, mais l'obtient via une interface au moment de l'appel de la méthode. Si la vue n'existe plus, l'appel ne se produit simplement pas.
• Drapeaux d'état: La vue peut stocker un drapeau indiquant si elle est active. Avant d'effectuer une action nécessitant la vue, le présentateur vérifie ce drapeau.
• Désabonnement RxJava: Si l'interaction utilise Observable/Flowable, il est possible de gérer l'abonnement et de se désabonner lors de la destruction de la vue.

// Dans le présentateur
private var disposable: Disposable? = null

fun loadData() {
    disposable = model.getData()
        .subscribeOn(Schedulers.io())
        .observeOn(AndroidSchedulers.mainThread())
        .subscribe({ data ->
            view?.showData(data) // Vérification de null
        }, { error ->
            view?.showError(error) // Vérification de null
        })
}

fun detachView() {
    disposable?.dispose() // Désabonnement lors de la destruction de la vue
    view = null // Réinitialisation de la référence à la vue
}

• Callback avec vérification de la vue: Passer comme callback un objet qui vérifie l'existence de la vue avant d'effectuer l'action.

// Dans le présentateur
fun processData(data: Data) {
    val uiCallback = object : UICallback {
        override fun onSuccess(result: Result) {
            view?.showResult(result) // Vérification de null
        }
        override fun onError(error: Throwable) {
            view?.showError(error) // Vérification de null
        }
    }
    model.doAsyncOperation(data, uiCallback)
}

// Dans la vue
interface UICallback {
    fun onSuccess(result: Result)
    fun onError(error: Throwable)
}

• Composants sensibles au cycle de vie: Utilisation de composants qui sont conscients du cycle de vie (par exemple, LifecycleObserver dans les composants architecturaux Android) pour annuler automatiquement les requêtes lors du changement d'état de la vue.

// Dans le présentateur, qui est un LifecycleObserver
class MyPresenter(private val view: MyView) : LifecycleObserver {

    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    fun onDestroy() {
        // Annuler les opérations lors de la destruction de la vue
    }

    // ...
}

// Dans la vue
lifecycle.addObserver(presenter)