Nuestro primer esquema,
el modelo vista y controlador te lo voy a explicar de la siguiente forma.
El modelo, el modelo básicamente van a ser nuestros datos,
todas nuestras bases de datos en Android.
Para ello, el manejador de base de datos que utiliza Android es SQLite.
El modelo.
Luego tenemos la vista.
La vista, como hemos estado platicando, pues son nuestras interfaces gráficas,
todos nuestros layouts, nuestros archivos xml.
Y el controlador es precisamente aquél que se va a encargar
de estar manipulando la vista pero también manipulando los datos.
¿Y te acuerdas quién dijimos que es?
Nuestros archivos de Java.
Todas nuestras clases de Java van a ser nuestros controladores.
Es decir, si lo vemos en términos de un activity,
un activity tiene un layout que sería la vista, y también tiene una clase de Java.
Este sería nuestro controlador.
Si nosotros en algún momento ejecutamos una consulta a una base de datos desde
el controlador, estaríamos completando el esquema, modelo, vista y controlador.
Nuestro siguiente patrón es un patrón que últimamente se está utilizando bastante en
el desarrollo de apps en Android.
Es el modelo vista presentador.
¿Cuál es la diferencia entre el controlador?
Bueno, se ha dejado de usar un poco el anterior modelo vista controlador porque,
pues, cuando el controlador quiere ejecutar una consulta en la base de datos,
y al mismo tiempo el controlador tiene que mantener toda la relación, todo el control
entre la vista, se dice que es demasiada carga para un solo archivo de Java.
Entonces, de pronto llegan a ser archivos de Java enormes, enormes, enormes.
Muy complicados de leer y muy complicados de entender,
puesto que maneja todo el control de las vistas,
de los views, y además todo el control de la base de datos.
Para ello se creó este modelo, este esquema modelo vista presentador.
Básicamente la vista se ha configurado de tal forma que ahora la vista va a ser
el archivo xml y nuestro archivo de Java de nuestro activity.
Ambos archivos van a componer la vista,
tanto el controlador que teníamos anteriormente, la clase activity,
como también nuestro layout, nuestro archivo xml.
Eso será nuestra vista.
Ahora, el modelo.
El modelo se conserva tal cual, el modelo serán todos nuestros datos,
nuestras bases de datos escritas con SQLite.
Ahora, para poder acceder desde nuestra vista, que es nuestra activity completa,
hasta el modelo, se ha creado un intermediario que es el presentador.
El presentador se va a encargar de manejar toda la lógica,
y además que todas las transacciones se hagan correctamente.
El presentador va a interactuar con el controlador que
dejamos por allá con nuestra actividad,
y además ese controlador va a estar por ahí jugando con toda la vista.
Entonces el presentador va a estar interactuando con la vista completa,
y además también con nuestro modelo de datos.