¿177€ por una consola que acaba de salir? Con un precio así puedo hacerme ya con mi primera consola de octava generación, y comprar una PS4 o una XBOX 720 en el futuro.

Además, para hacer la oferta aún más tentadora, los creadores de Wiikey anunciaron hace unos días que ya tienen casi lista la primera solución para cargar copias de seguridad en Wii U. ¡Desde disco externo USB y sin soldaduras!

La opción más interesante es AndroidAnnotations, ya que es muy completa, no impone penalización alguna en el rendimiento y no nos obliga a que nuestras actividades extiendan de una cierta clase, lo que al carecer Java de herencia múltiple complicaría ligeramente el uso de librerías como ActionBarSherlock. ¿Suena bien? Entonces genera un proyecto con AndroidAnnotations en AndroidKickstarR y sigue leyendo; te aseguro que no te vas a arrepentir.

Asociar un layout a una actividad o fragmento

Sin AndroidAnnotations:

public class Actividad extends Activity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.actividad);
    }
}

Con AndroidAnnotations podemos usar la anotación @EActivity (de enhanced activity o actividad mejorada) y pasarle el identificador del layout:

@EActivity(R.layout.actividad)
public class MyActivity extends Activity {}

De forma parecida a las actividades, con la anotación @EFragment podemos obviar el método onCreateView del fragmento. Sin AndroidAnnotations:

public class Fragmento extends Fragment {
    public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
        View view = inflater.inflate(R.layout.fragmento, container, false);
        return view;
    }
}

Con AndroidAnnotations:

@EFragment(R.layout.fragmento)
public class Fragmento extends Fragment {
}

Inyección de vistas

Sin AndroidAnnotations:

public class Actividad extends Activity {
	Button btnGuardar;
	EditText txtNombre;

	@Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.actividad);
		
		btnGuardar = (Button) findViewById(R.id.btnGuardar);
		txtNombre = (EditText) findViewById(R.id.txtNombre);
    }
}

Con AndroidAnnotations usaríamos la anotación @ViewById pasando como parámetro el identificador de la vista

@EActivity(R.layout.actividad)
public class Actividad extends Activity {
	@ViewById(R.id.btnGuardar)
	Button btnGuardar;
	
	@ViewById(R.id.txtNombre)
	EditText txtNombre;
}

Si el nombre de la variable es igual al identificador de la vista el parámetro se puede obviar:

@EActivity(R.layout.actividad)
public class Actividad extends Activity {
	@ViewById Button btnGuardar;
	@ViewById EditText txtNombre;
}

También podemos inyectar fragmentos con @FragmentById

@EActivity(R.layout.actividad)
public class Actividad extends Activity {
	@ViewById Button btnGuardar;
	@ViewById EditText txtNombre;
	@FragmentById Fragmento fragmento;
}

Manipular las vistas

Si usamos @ViewById para inyectar la vistas, por la manera que tiene de funcionar AndroidAnnotations, no tendremos todavía las instancias asociadas en onCreate, por lo que si tenemos que hacer algo con las vistas tendremos que anotar uno o varios métodos con @AfterViews. Esto, que a alguno le puede parecer un incordio, a mí personalmente me gusta, porque prefiero extraer el resto del código a otros métodos siguiendo el Principio de Responsabilidad Única.

De esta forma un código como

public class Actividad extends Activity {
	TextView txtVersion;
	TextView txtFecha;

	@Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.actividad);
		
		txtVersion = (TextView) findViewById(R.id.txtVersion);
		txtFecha = (TextView) findViewById(R.id.txtFecha);
		
		establecerVersion();
		establecerFecha();
    }
	
	void establecerVersion() {
		try {
			PackageInfo infoPaquete = getPackageManager().getPackageInfo(getPackageName(), 0);
			txtVersion.setText(infoPaquete.versionName);
		} catch(NameNotFoundException e) {
			e.printStackTrace();
		}
	}
	
	void establecerFecha() {
		DateFormat formato = new SimpleDateFormat("dd-MM-yyyy HH:mm:ss");
		Date fecha = new Date();
		String strFecha = formato.format(fecha);
		txtFecha.setText(strFecha);
	}
}

se convertiría en lo siguiente

@EActivity(R.layout.actividad)
public class Actividad extends Activity {
	@ViewById TextView txtVersion;
	@ViewById TextView txtFecha;
	
	@AfterViews
	void establecerVersion() {
		try {
			PackageInfo infoPaquete = getPackageManager().getPackageInfo(getPackageName(), 0);
			txtVersion.setText(infoPaquete.versionName);
		} catch(NameNotFoundException e) {
			e.printStackTrace();
		}
	}
	
	@AfterViews
	void establecerFecha() {
		DateFormat formato = new SimpleDateFormat("dd-MM-yyyy HH:mm:ss");
		Date fecha = new Date();
		String strFecha = formato.format(fecha);
		txtFecha.setText(strFecha);
	}
}

Eventos

Android cuenta con un atributo XML android:onClick con el que es muy rápido y sencillo asociar un listener a un evento clic. El equivalente en AndroidAnnotations es la anotación @Click, a la que se le pasa el identificador de la vista a la que se asocia el listener (se puede obviar en caso de que el nombre del método coincida con el identificador de la vista o que sea igual pero con el sufijo Clicked).

@EActivity(R.layout.actividad)
public class Actividad extends Activity {
	@Click(R.id.button1)
	void mostrarVersion() {
		// ...
	}

	@Click
	void mostrarFecha() {
		// ...
	}

	@Click
	void guardarClicked() {
		// ...
	}
}

En este caso la ventaja de las anotaciones no es tan obvia; quizás el poder ver la asociación entre la vista y el método en un golpe de vista. Tiene mayor interés el que podamos asociar listeners para unos pocos eventos más de forma igual de sencilla, con @LongClick para pulsaciones largas o @TextChange para cambios de texto.

Menús

Con la anotación @OptionsMenu podemos inflar el XML de menú, ahorrándonos sobreescribir onCreateOptionsMenu. Con @OptionsItem asociamos las distintas opciones de menú con distintos listeners, pasando el id de la opción a la anotación (también se puede obviar el id si coincide con el nombre del método, o si es igual pero con el sufijo Selected).

Versión sin anotaciones:

public class Actividad extends Activity {
	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.actividad);
	}

	@Override
	public boolean onCreateOptionsMenu(Menu menu) {
		getMenuInflater().inflate(R.menu.actividad, menu);
		return true;
	}

	
	@Override
	public boolean onOptionsItemSelected(MenuItem item) {
		switch (item.getItemId()) {
			case R.id.actualizar:
				actualizar();
				return true;
			case R.id.acercaDe:
				acercaDeSelected();
				return true;
			default:
			  return false;
		}
	}

	
	void actualizar() {
		// ...
	}	

	
	void acercaDeSelected() {
		// ...
	}	
}

Versión con anotaciones:

@EActivity(R.layout.actividad)
@OptionsMenu(R.menu.actividad)
public class Actividad extends Activity {
	@OptionsItem(R.id.actualizar)
	void actualizar() {
		// ...
	}	

	@OptionsItem
	void acercaDeSelected() {
		// ...
	}	
}

Inyección de recursos

Para cada tipo de recurso existe una anotación que permite inyectar dicho recurso en nuestra clase pasándole simplemente el identificador (o sin pasarle nada si el nombre del recurso coincide con el de la variable): AnimationRes, BooleanRes, ColorRes, ColorStateListRes, DimensionPixelOffsetRes, DimensionPixelSizeRes, DimensionRes, DrawableRes, HtmlRes, IntArrayRes, IntegerRes, LayoutRes, MovieRes, StringArrayRes, StringRes, TextArrayRes, TextRes.

De esta forma en lugar de:

String nombreApp = getResources().getString(R.string.nombreApp);

simplemente podríamos escribir:

@StringRes String nombreApp;

Además, en el caso concreto de que queramos obtener una cadena HTML de un archivo de recurso y establecerla como texto en un TextView, podemos llevar a cabo ambos pasos con una simple anotación @FromHtml.

Hilos de ejecución

¿Harto de usar AsyncTask o similares para ejecutar un cierto código en un hilo distinto del principal o de interfaz de usuario?

void ejecutarTareaSegundoPlano(URL urls) {
	new AsyncTask<URL, Integer, Long> {
		protected Long doInBackground(URL... urls) {
			int numUrls = urls.length;
			Long tamanyoDescarga = 0;
			for (int i = 0; i < numUrls; i++) {
				tamanyoDescarga += ClienteHttp.descargar(urls[i]);
				publishProgress((int) ((i / (float) numUrls) * 100));
			}
			return totalSize;
		}

		protected void onProgressUpdate(Integer... progreso) {
			actualizarProgreso(progreso[0]);
		}

		protected void onPostExecute(Long tamanyoDescarga) {
			mostrarDialogo("Descargados " + tamanyoDescarga[0] + " bytes");
		}
	}.execute();
}

¿Qué tal si pudieras usar la anotación @Background para indicar que un método debe ejecutarse en un hilo en segundo plano y @UiThread para que se ejecute en el hilo de interfaz de usuario? De esta forma el ejemplo anterior se reduciría a:

@Background
void descargarArchivos(URL urls) {
	int numUrls = urls.length;
	Long tamanyoDescarga = 0;
	for (int i = 0; i < numUrls; i++) {
		tamanyoDescarga += ClienteHttp.descargar(urls[i]);
		actualizarEstadoDescarga((int) ((i / (float) numUrls) * 100));
	}
	mostrarDialogoFinDescarga(tamanyoDescarga);
}

@UiThread
void actualizarEstadoDescarga(int progreso) {
	actualizarProgreso(progreso);
}

@UiThread
void mostrarDialogoFinDescarga(Long tamanyoDescarga) {
	mostrarDialogo("Descargados " + tamanyoDescarga + " bytes");
}

Guardar y recuperar el estado

Esta es otra de esas tareas repetitivas que suponen gran cantidad de código. Comparemos una implementación típica con su correspondiente versión con anotaciones.

public class Actividad extends Activity {
    Jugador jugador;
    int puntuacion;

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);

        if(savedInstanceState != null) { 
            jugador = (Jugador)savedInstanceState.getSerializable("jugador");
			puntuacion = savedInstanceState.getInt("puntuacion");
        }
    }

    @Override
    protected void onSaveInstanceState(Bundle outState) {
        super.onSaveInstanceState(outState);
        outState.putSerializable("jugador", jugador);
        outState.putInt("puntuacion", puntuacion);
    }
}

@EActivity(R.layout.actividad)
public class Actividad extends Activity {
    @InstanceState
    Jugador jugador;

    @InstanceState
    int puntuacion;
}

Otras funcionalidades de interés

• @Trace nos permite trazar la ejecución de un método escribiendo una entrada en el log cuando se entra y se sale del método.
• @HierarchyViewerSupport permite utilizar la herramienta Hierarchy Viewer aunque no dispongamos de un teléfono con permisos de root o de desarrollo
• @RoboGuice nos permite integrar AndroidAnnotation con el framework de inyección de dependencias del mismo nombre (basado en Guice, de Google)
• @OrmLiteDao nos permite integrar AndroidAnnotation con el framework de mapeo objeto-relacional OrmLite
• @EView y @EViewGroup facilitan la creación de vistas personalizadas
• @SystemService nos permite inyectar un servicio del sistema

Considera este fragmento de código, que podríamos encontrar varias veces repetido en una página JSF y que genera una caja de texto HTML con una etiqueta asociada y con un span en el que mostrar errores de validación para ese campo:

<h:outputLabel value="Nombre:" for="nombre"/>
<h:inputText id="nombre" label="Nombre" required="true" value="#{controlador.entidad.nombre}"/>
<h:message for="nombre"/>

NetBeans, y casi todo IDE que se precie, tiene una característica de plantillas de código con la que insertar automáticamente el código de la plantilla escribiendo una abreviatura que le hayamos asignado y pulsando Tab.

Pero casi todos los IDE van un paso más allá y permiten parametrizar estas plantillas de código, de forma que podamos sustituir estos parámetros por sus respectivos valores antes de la inserción final.

En NetBeans podemos consultar las plantillas de código predefinidas y añadir otras nuevas en Tools -> Options -> Editor -> Code Templates. La plantilla correspondiente al fragmento anterior tendría este aspecto, con los parámetros a sustituir siguiendo la sintaxis ${nombre del parámetro}:

<h:outputLabel value="${nombre}:" for="${id}"/>
<h:inputText id="${id}" label="${nombre}" required="true" value="#{controlador.entidad.${id}}"/>
<h:message for="${id}"/>

Al escribir el atajo que hayamos asociado al fragmento de código, NetBeans insertará el fragmento en esa línea y moverá el cursor al primer parámetro. Sólo tendremos que escribir el valor que queramos darle y pulsar Enter para que se cambie el valor en ese parámetro y todos los del mismo nombre. NetBeans situará el cursor en el siguiente parámetro para que podamos darle un valor, y así sucesivamente.

Echadle una oída

Toma ejemplo de Vytas Simanavicius, honrado ciudadano lituano, vicepresidente de la asociación antipiratería de su país, que no contento con dedicar sus días a la lucha contra el cáncer de la piratería, dedica sus noches al noble arte del tráfico de drogas para poder pagar por los discos de Bisbal. Un trabajador incansable, ejemplo e inspiración para todos.

Para solucionarlo sólo tienes que descargar el código fuente de la versión de Android para la que estés desarrollando utilizando el Android SDK Manager (paquete “Sources for Android SDK”), pulsar el botón Attach Source en Eclipse, seleccionar External Folder y buscar la carpeta en la que se ha descargado el código fuente; normalmente android/sdk/sources/android-nivel api

Esta aplicación funciona interceptando las llamadas de red de las aplicaciones que carga. Sólo tenéis que crear un acceso directo a la aplicación que queráis forzar a utilice una determinada red, con ForceBindIP como ejecutable y la IP y la ruta de la aplicación a lanzar como parámetros. Por ejemplo:

ForceBindIP 174.193.48.35 “C:\Archivos de programa\Internet Explorer\iexplore.exe”

Si la red asigna IP de forma dinámica, tendrás que sustituir la IP por la clave que identifica a la red en el registro de Windows. Para ello, haz clic en el botón de Inicio, selecciona Ejecutar y escribe el comando regedit, lo que abrirá el editor de registro. En HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\Tcpip\Parameters\Interfaces busca la clave con un valor para DhcpIPAddress igual a la IP asignada actualmente para esa interfaz.

ForceBindIP {11388731-F073-4EC4-A52C-3EFA7F325A1D} “C:\Archivos de programa\Internet Explorer\iexplore.exe”

Por último, también puede resultar útil añadir entradas en el menú contextual de los ejecutables con los que seleccionar si ejecutar la aplicación con una interfaz de red u otra. Esto lo podríamos hacer con un archivo de registro como el siguiente; sólo tenéis que guardarlo en un archivo de texto con extensión .reg, acordándoos de cambiar las claves de las interfaces por vuestras claves o IPs.

Windows Registry Editor Version 5.00

[HKEY_CLASSES_ROOT\exefile\shell\EjecutarWifi]
@="Ejecutar por WiFi"

[HKEY_CLASSES_ROOT\exefile\shell\EjecutarWifi\command]
@="ForceBindIP {11388731-F073-4EC4-A52C-3EFA7F325A1D} \"%l\""

[HKEY_CLASSES_ROOT\exefile\shell\EjecutarLAN]
@="Ejecutar por LAN"

[HKEY_CLASSES_ROOT\exefile\shell\EjecutarLAN\command]
@="ForceBindIP {EAEA78D4-05AA-4421-BD99-0B6C89FB9FC5} \"%l\""

1. Construyendo tu primera aplicación
2. Gestionando el ciclo de vida de la actividad
3. Soportando distintos dispositivos
4. Construyendo una interfaz de usuario dinámica con fragmentos
5. Guardando información
6. Interactuando con otras aplicaciones
7. Compartiendo contenido