Mi az a MV-minta?

MV-minták (Model-View-ViewModel, Model-View-Presenter, Model-View-Controller) architekturális minták, amelyek elválasztják a megjelenítést (View), az üzleti logikát (Model) és a megjelenítési logikát (ViewModel/Presenter). Céljuk a felelősségek szétválasztásával a karbantarthatóság, tesztelhetőség és skálázhatóság javítása az alkalmazásban.

MVC (Model-View-Controller)

• Model: Adatokat és üzleti logikát képvisel.
• View: A Model-ből származó adatokat jeleníti meg.
• Controller: Kezeli a felhasználói műveleteket, frissíti a Model-t és kiválasztja a View-t a megjelenítéshez.

Androidban a View (aktivitás/részletek) gyakran ötvözi a View és Controller funkciókat, ami megnehezíti a tesztelést.

MVP (Model-View-Presenter)

• Model: Adatokat és üzleti logikát képvisel.
• View: Passzív felület, amely a Presenter által átadott adatokat jeleníti meg, és továbbítja a felhasználói műveleteket.
• Presenter: A megjelenítési logikát tartalmazza, kommunikál a Model-lel, és a felületet frissíti interfészen keresztül.

Biztosítja a View és a logika közötti jobb szétválasztást, és tesztelhetőbbé teszi a Presentert.

// MVP-ben a View interfész példája
interface UserProfileView {
    fun showLoading()
    fun hideLoading()
    fun displayUserInfo(user: User)
    fun showError(message: String)
}

// Presenter példa
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("Felhasználó betöltése sikertelen")
            }
        }
    }
}

MVVM (Model-View-ViewModel)

• Model: Adatokat és üzleti logikát képvisel. Observable-t használ a változások értesítésére.
• View: A ViewModel-ből származó adatokat jeleníti meg, és felhasználói műveleteket küld neki. Databinding-et használ a View és a ViewModel összekapcsolására.
• ViewModel: Az adatokat a View számára könnyen kezelhető formátumban szolgáltatja, tartalmazza a megjelenítési logikát. Nincs közvetlen hozzáférése a View-hoz.

Az observátorok (LiveData, Flow) és a databinding mechanizmusok segítségével automatikusan frissíti a View-t, amikor a ViewModel-ben lévő adatok változnak. A ViewModel teljesen független az Android keretrendszertől, és könnyen tesztelhető.

// LiveData-val példázott ViewModel
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 = "Felhasználó betöltése sikertelen"
            }
        }
    }
}

Összehasonlítás:

Modell	View és Logika kapcsolata	Logika tesztelhetősége	Logika Android-tól való függése
MVC	Szoros (Android View gyakran Controller)	Közepes	Magas
MVP	Szabad (interfészen keresztül)	Magas	Alacsony (A Presenter nem függ az Android UI-tól)
MVVM	Szabad (figyelőkkel és databinding-gel)	Magas	Hiányzik (A ViewModel nem függ az Android UI-tól)

A modell kiválasztása a projekt követelményeitől és a csapat preferenciáitól függ. A MVVM az ajánlott megközelítés az Android modern fejlesztésében, különösen az Android Jetpack komponensek (ViewModel, LiveData, Data Binding) használatával.