Wat zijn MV-patronen?

De MV-patronen (Model-View-ViewModel, Model-View-Presenter, Model-View-Controller) zijn architecturale patronen die presentatie (View), bedrijfslogica (Model) en presentatie-logica (ViewModel/Presenter) scheiden. Het doel is om de onderhoudbaarheid, testbaarheid en schaalbaarheid van de applicatie te verbeteren door verantwoordelijkheden te scheiden.

MVC (Model-View-Controller)

• Model: Vertegenwoordigt gegevens en bedrijfslogica.
• View: Toont gegevens uit het Model.
• Controller: Verwerkt gebruikersacties, werkt het Model bij en kiest de View om weer te geven.

In Android combineert de View (activiteit/fragment) vaak functies van View en Controller, wat testen bemoeilijkt.

MVP (Model-View-Presenter)

• Model: Vertegenwoordigt gegevens en bedrijfslogica.
• View: Passief interface dat gegevens toont die door de Presenter worden doorgegeven en gebruikersacties doorgeeft.
• Presenter: Bevat de presentatie-logica, werkt samen met het Model en werkt de View bij via een interface.

Biedt een betere scheiding tussen View en logica, waardoor de Presenter beter testbaar wordt.

// Voorbeeld van View-interface in MVP
interface UserProfileView {
    fun showLoading()
    fun hideLoading()
    fun displayUserInfo(user: User)
    fun showError(message: String)
}

// Voorbeeld van 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("Fout bij het laden van gebruiker")
            }
        }
    }
}

MVVM (Model-View-ViewModel)

• Model: Vertegenwoordigt gegevens en bedrijfslogica. Gebruikt Observable om wijzigingen te melden.
• View: Toont gegevens uit de ViewModel en verzendt gebruikersacties. Gebruikt data binding om View en ViewModel te koppelen.
• ViewModel: Biedt gegevens voor de View in een geschikt formaat, bevat de presentatie-logica. Heeft geen directe toegang tot de View.

Gebruikt observatiemechanismen (LiveData, Flow) en data binding voor automatische updates van de View bij gegevenswijzigingen in de ViewModel. Maakt de ViewModel volledig onafhankelijk van het Android-framework en goed testbaar.

// Voorbeeld van ViewModel met 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 = "Fout bij het laden van gebruiker"
            }
        }
    }
}

Vergelijking:

Patron	Relatie tussen View en Logica	Testbaarheid van Logica	Afhankelijkheid van Android
MVC	Sterk (in Android is View vaak de Controller)	Gemiddeld	Hoog
MVP	Vrij (via interface van View)	Hoog	Laag (Presenter is onafhankelijk van Android UI)
MVVM	Vrij (via observatoren en data binding)	Hoog	Afwezig (ViewModel is onafhankelijk van Android UI)

De keuze van het patroon hangt af van de projectvereisten en de voorkeuren van het team. MVVM met Android Jetpack-componenten (ViewModel, LiveData, Data Binding) wordt aanbevolen in moderne Android-ontwikkeling.