Que sont les modèles MV?

Les patrons MV (Model-View-ViewModel, Model-View-Presenter, Model-View-Controller) sont des patrons architecturaux qui séparent la vue (View), la logique métier (Model) et la logique de présentation (ViewModel/Presenter). L'objectif est d'améliorer la maintenabilité, la testabilité et la scalabilité de l'application en séparant les responsabilités.

MVC (Model-View-Controller)

• Model: Représente les données et la logique métier.
• View: Affiche les données du Model.
• Controller: Traite les actions de l'utilisateur, met à jour le Model et choisit la View à afficher.

Dans Android, la View (activité/fragment) combine souvent les fonctions de View et Controller, ce qui complique les tests.

MVP (Model-View-Presenter)

• Model: Représente les données et la logique métier.
• View: Interface passive qui affiche les données passées par le Presenter et transmet les actions de l'utilisateur.
• Presenter: Contient la logique de présentation, interagit avec le Model et met à jour la View via une interface.

Offre une meilleure séparation entre View et logique, rendant le Presenter plus facile à tester.

// Exemple d'interface View en MVP
interface UserProfileView {
    fun showLoading()
    fun hideLoading()
    fun displayUserInfo(user: User)
    fun showError(message: String)
}

// Exemple de Presenter
class UserProfilePresenter(private val view: UserProfileView, private val repository: UserRepository) {
    fun loadUserProfile(userId: String) {
        view.showLoading()
        repository.getUser(userId) { user ->
            view.hideLoading()
            if (user != null) {
                view.displayUserInfo(user)
            } else {
                view.showError("Échec du chargement de l'utilisateur")
            }
        }
    }
}

MVVM (Model-View-ViewModel)

• Model: Représente les données et la logique métier. Utilise Observable pour notifier des changements.
• View: Affiche les données du ViewModel et envoie les actions de l'utilisateur. Utilise data binding pour lier la View et le ViewModel.
• ViewModel: Fournit des données à la View dans un format pratique, contient la logique de présentation. N'a pas d'accès direct à la View.

Utilise des mécanismes d'observation (LiveData, Flow) et de data binding pour mettre à jour automatiquement la View lors des changements de données dans le ViewModel. Rend le ViewModel totalement indépendant du framework Android et facilement testable.

// Exemple de ViewModel avec LiveData
class UserProfileViewModel(private val repository: UserRepository) : ViewModel() {
    private val _user = MutableLiveData<User?>()
    val user: LiveData<User?> = _user

    private val _loading = MutableLiveData<Boolean>()
    val loading: LiveData<Boolean> = _loading

    private val _error = MutableLiveData<String?>()
    val error: LiveData<String?> = _error

    fun loadUserProfile(userId: String) {
        _loading.value = true
        repository.getUser(userId) { user ->
            _loading.value = false
            if (user != null) {
                _user.value = user
                _error.value = null
            } else {
                _user.value = null
                _error.value = "Échec du chargement de l'utilisateur"
            }
        }
    }
}

Comparaison:

Patron	Relation entre View et Logique	Testabilité de la logique	Dépendance de la logique à Android
MVC	Forte (en Android, View est souvent le Controller)	Moyenne	Élevée
MVP	Libre (via interface View)	Élevée	Faible (Presenter ne dépend pas de l'UI Android)
MVVM	Libre (via observateurs et data binding)	Élevée	Absente (ViewModel ne dépend pas de l'UI Android)

Le choix du patron dépend des exigences du projet et des préférences de l'équipe. MVVM utilisant les composants Android Jetpack (ViewModel, LiveData, Data Binding) est l'approche recommandée dans le développement Android moderne.