En esta entrada, voy a explicar a grandes rasgos, cómo montar una buena estructura de directorios y clases para una aplicación desarrollada con Android.
Como bien sabréis, el modelo más clásico para desarrollar aplicaciones de todo tipo (salvo casos concretos), es el MVC. No me voy a entretener explicando que es, así que quien tenga interés en conocerlo más a fondo, que visite este enlace.
A grandes rasgos, tenemos:
* M: [Modelo]: Donde definiremos todos los objetos que existirán en nuestra aplicación
* V: [Vista] Donde tendremos toda la parte visual (esencialmente, Layouts, Activities…)
* C: [Controlador] Aquí programaremos todo lo que son Managers.
Empezaremos creando una estructura de directorios similar a esta (a partir de ahora, es la que usaremos para ir trabajando sobre el contenido de este blog).
Y aquí tenemos la estructura más simple (pero ordenada) de una aplicación Android
¿Qué tenemos aquí?
En el directorio “activity“, iremos incluyendo las activities que vayamos desarrollando. He dejado una, AndroidToastE1Activity.java aislada de la estructura. Es una manía mía pero podéis obviarla. Normalmente, uso esa Activity a modo de testeo de los resultados que veríamos en una Activity en concreto. Así, no tengo que ir siguiendo siempre el flujo de ejecución para llegar a un caso concreto.
Seguidamente, tenemos el directorio “controller“. Aquí definiremos, por un lado la Interfaz de la clase y por otro su implementación. El controller, deberá ser un Singleton. ¿Porqué Singleton?, pues porque el controller instanciará todos los managers y hará el trabajo sucio de recoger el contexto de las activities por nosotros.
CREACIÓN DEL CONTROLLER
Ahora, vamos a ver, cómo crear este “Controller” que de ahora en adelante, usaremos para nuestras aplicaciones de Android.
Crearemos una interfaz ControllerInterface.java y la pondremos en el package com.danielsanteugini.com.androidtoast.controller y una clase, que implementará este Controller, llamada Controller.java
Código fuente para ControllerInterface.java:
package com.danielsanteugini.androidtoast.controller
public interface ControllerInterface {
public void setActivity(Activity activity);
}
Seguidamente, implementaremos la clase que requiere de la interfaz ControllerInterface. El código es un singleton puro, así que explicaremos un poco por encima, qué hace el código.
package com.danielsanteugini.androidtoast.controller.impl;
import android.app.Activity;
import android.util.Log;
import com.doubleyou.evax.epc.controller.ControllerInterface;
public class Controller implements ControllerInterface {
private static Controller instance;
private Activity activity;
// Metodo estatico que nos permite obtener
// la instacia actual del controller
public static synchronized Controller getInstance() {
// Si nunca se ha instanciado el controller
// lo hacemos ahora, llamando al constructor privado
if (instance == null) {
instance = new Controller();
}
// Devolvemos si o si la instancia del controller.
// Si ya existía, devolveremos la instancia que habíamos
// creado ya. Sino, la que hemos creado en el código
// del if.
return instance;
}
private Controller(){
// Constructor privado
}
// Metodo que tenemos que llamar desde la activity que vaya
// a usar el controller.
// Se hará de la siguiente forma: setActivity(this)
public void setActivity(Activity activity) {
Log.d(this.getClass().getName(),"Activity "+activity.getClass().getName()+" setted");
this.activity = activity;
}
}
Nota: Mientras escribía esta entrada, me he dado cuenta de que para ser más puristas, deberíamos modificar un poco la implementación del Controller. Lo ideal, sería que cada vez que nos pidan la instancia del Controller, miremos si la “Activity” privada está definida. Es decir, si nos han ejecutado el método setActivity. En caso de que no esté definida y además, ya tengamos definida la instancia del controller (es decir, ya nos han llamado alguna vez), lanzaremos una excepción para avisar de que es obligatorio setear la Activity.
En la siguiente entrada, explicaré cómo crear nuestro primer Manager (muy simple).
