O que são os padrões MV?

Os padrões MV (Model-View-ViewModel, Model-View-Presenter, Model-View-Controller) são padrões arquiteturais que separam a apresentação (View), a lógica de negócio (Model) e a lógica de apresentação (ViewModel/Presenter). O objetivo é melhorar a manutenção, testabilidade e escalabilidade da aplicação através da separação de responsabilidades.

MVC (Model-View-Controller)

• Model: Representa dados e lógica de negócio.
• View: Mostra dados do Model.
• Controller: Processa ações do utilizador, atualiza o Model e escolhe a View para mostrar.

No Android, a View (atividade/fragmento) frequentemente combina funções de View e Controller, o que dificulta os testes.

MVP (Model-View-Presenter)

• Model: Representa dados e lógica de negócio.
• View: Interface passiva que mostra dados passados pelo Presenter e transmite ações do utilizador.
• Presenter: Contém a lógica de apresentação, interage com o Model e atualiza a View através de uma interface.

Proporciona uma melhor separação entre View e lógica, tornando o Presenter mais fácil de testar.

// Exemplo de interface View em MVP
interface UserProfileView {
    fun showLoading()
    fun hideLoading()
    fun displayUserInfo(user: User)
    fun showError(message: String)
}

// Exemplo 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("Falha ao carregar o utilizador")
            }
        }
    }
}

MVVM (Model-View-ViewModel)

• Model: Representa dados e lógica de negócio. Usa Observable para notificar mudanças.
• View: Mostra dados do ViewModel e envia ações do utilizador. Usa data binding para ligar a View e o ViewModel.
• ViewModel: Fornece dados para a View num formato conveniente, contém a lógica de apresentação. Não tem acesso direto à View.

Utiliza mecanismos de observação (LiveData, Flow) e data binding para atualizar automaticamente a View quando os dados no ViewModel mudam. Torna o ViewModel totalmente independente do framework Android e facilmente testável.

// Exemplo de ViewModel com 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 = "Falha ao carregar o utilizador"
            }
        }
    }
}

Comparação:

Padrão	Relação entre View e Lógica	Testabilidade da Lógica	Dependência da Lógica do Android
MVC	Forte (em Android, View muitas vezes é o Controller)	Média	Alta
MVP	Livre (através de interface View)	Alta	Baixa (Presenter não depende da UI Android)
MVVM	Livre (através de observadores e data binding)	Alta	Ausente (ViewModel não depende da UI Android)

A escolha do padrão depende dos requisitos do projeto e das preferências da equipa. MVVM com componentes Android Jetpack (ViewModel, LiveData, Data Binding) é a abordagem recomendada no desenvolvimento Android moderno.