Arquitectura MVP: Implementación en Proyectos Android

¿Cómo estructurar un proyecto con arquitectura MVP en Android?

La implementación de una arquitectura como Modelo-Vista-Presentador (MVP) puede parecer abrumadora al principio, pero con una guía clara, puedes lograr un diseño organizado y eficiente en tu aplicación Android. A continuación, exploramos la estructura básica para un proyecto que sigue esta arquitectura.

¿Qué componentes forman la base de la arquitectura MVP?

En una arquitectura MVP, desglosamos la funcionalidad de la aplicación en tres capas principales:

1. Modelo: Se encarga de la lógica de acceso a los datos, ya sea desde una base de datos local o una fuente en red.
2. Vista: Muestra la información al usuario y lo notifica de sus interacciones.
3. Presentador: Actúa como intermediario entre la Vista y el Modelo, manejando la lógica de la aplicación.

¿Cómo organizamos el proyecto en paquetes?

Para mantener nuestro proyecto organizado, utilizamos el siguiente esquema de paquetes:

• vista (view en inglés): Contiene los fragmentos y actividades responsables de presentar la interfaz gráfica al usuario.

  public class HomeFragment extends Fragment {
      private RecyclerView.Adapter favoriteTransferAdapter;
      private ProgressBar circularProgressBar;
      
      // Configuración de la vista
      private void setupView() {
          favoriteTransferAdapter = new FavoriteTransferAdapter();
          circularProgressBar = findViewById(R.id.progress_circular);
          circularProgressBar.setVisibility(View.GONE);
      }
  }
  

• presentador (presenter en inglés): Alojamos aquí la lógica que maneja las interacciones entre la Vista y el Modelo.

  public class HomePresenter {
      private final HomeInteractor interactor;
  
      public HomePresenter() {
          interactor = new HomeInteractor();
      }
  
      public List<FavoriteTransfer> loadFavoriteTransfers() {
          return interactor.getFavoriteTransfers();
      }
  }
  

• interactor: En este paquete colocamos la gestión de comunicaciones con los datos.

  public class HomeInteractor {
      public List<FavoriteTransfer> getFavoriteTransfers() {
          // Implementación para obtener datos
          return new ArrayList<>();
      }
  }
  

¿Cómo asegurar una comunicación eficaz entre las capas?

Para garantizar una comunicación efectiva, definimos contratos (interfaces) para cada capa. Estos contratos especifican las funciones disponibles y se alojan en un paquete compartido.

• Contrato de Vista y Presentador

  public interface HomeContract {
      interface View {
          void showProgress();
          void hideProgress();
          void displayFavoriteTransfers(List<FavoriteTransfer> transfers);
      }
  
      interface Presenter {
          void fetchFavoriteTransfers();
      }
  }
  

¿Cómo implementar estos contratos en las clases correspondientes?

Implementamos los contratos en nuestras clases de la Vista y del Presentador. De este modo, aseguramos que cada clase cumple con las expectativas definidas para su función.

• Implementación en la Vista

  public class HomeFragment extends Fragment implements HomeContract.View {
      @Override
      public void showProgress() {
          circularProgressBar.setVisibility(View.VISIBLE);
      }
  
      @Override
      public void hideProgress() {
          circularProgressBar.setVisibility(View.GONE);
      }
  
      @Override
      public void displayFavoriteTransfers(List<FavoriteTransfer> transfers) {
          favoriteTransferAdapter.setTransfers(transfers);
      }
  }
  

• Implementación en el Presentador

  public class HomePresenter implements HomeContract.Presenter {
      private final HomeContract.View view;
  
      public HomePresenter(HomeContract.View view) {
          this.view = view;
      }
  
      @Override
      public void fetchFavoriteTransfers() {
          view.showProgress();
          List<FavoriteTransfer> transfers = interactor.getFavoriteTransfers();
          view.hideProgress();
          view.displayFavoriteTransfers(transfers);
      }
  }
  

Con esta estructura básica, tu proyecto Android con arquitectura MVP estará bien organizado, asegurando una separación clara de responsabilidades y facilidad para el mantenimiento del código. ¡Continúa perfeccionando tus habilidades de arquitectura y verás cómo se fortalecen tus desarrollos móviles!