Zlib es una librería que proporciona funciones que nos permiten realizar tareas de compresión y descompresión usando el formato GZIP. En esta entrada vamos a ver algunos ejemplos sencillos de compresión de archivos usando dicha librería, y además veremos cómo funcionan las librerías adicionales para comprimir archivos en ZIP y Bunzip… aunque también existen otros formatos disponibles como rar, lzf y phar.

Comprimir y descomprimir usando el formato GZIP

Este es un ejemplo básico en donde se comprime y descomprime un archivo:

function descomprimir($origen, $destino) {
  $string = implode("", gzfile($origen));
  $fp = fopen($destino, "w");
  fwrite($fp, $string, strlen($string));
  fclose($fp);
} 

function comprimir($origen, $destino) {
  $fp = fopen($origen, "r");
  $data = fread ($fp, filesize($origen));
  fclose($fp);
  $zp = gzopen($destino, "w9");
  gzwrite($zp, $data);
  gzclose($zp);
}
comprimir("archivo.txt","archivo.gz");
descomprimir("archivo.gz","archivo2.txt");

Esta es una breve descripción de las funciones para Gzip incluidas en Zlib:

• gzclose — Cierra un puntero gz-file
• gzcompress — Comprime una cadena de texto
• gzencode — Crea una cadena de texto comprimida en gzip
• gzeof — Verifica si es el fin del archivo en un puntero gz-file
• gzfile — Lee el contenido de un archivo gzip y lo almacena en un arreglo
• gzgetc — Obtiene el caracter al que apunta un gz-file pointer
• gzgets — Obtiene la linea a la que apunta un gz-file pointer
• gzgetss — Obtiene la linea a la que apunta un gz-file pointer y remueve las etiquetas HTML
• gzinflate — Descomprime una cadena comprimida
• gzopen — Abre un archivo gzip

Comprimir usando el formato Bunzip

Aquí un ejemplo muy básico:

function comprimir_bzip($origen, $destino){
    // abrir el archivo en modo escritura
    $bz = bzopen($destino, "w");
    // escribir el contenido del origen
    bzwrite($bz, file_get_contents($filename));
    // cerrar el archivo
    bzclose($bz);
}

Información adicional y lista de las funciones disponibles: PHP: Bunzip.

Comprimir usando el formato ZIP

En este caso se utilizan la clase ZipArchive:

function comprimir_zip($origen, $destino){
    $zip = new ZipArchive();
    if ($zip->open($destino, ZIPARCHIVE::CREATE)!==TRUE) {
        die("Error al crear el archivo");
    }
    $zip->addFile($origen, "/".basename($origen));
    $zip->close();
}

Verificar la existencia de las librerías

Esta es una manera sencilla de verificar si PHP fue compilado con soporte para estas librerías:

if( class_exists('ZipArchive') )
    echo "ZIP: OK\n";
if( function_exists('bzwrite') )
    echo "Bunzip: OK\n";
if( function_exists('gzwrite') )
    echo "gzip: OK\n";

Esta entrada, principalmente dedicada a mi mismo ya que se que se me va a olvidar cómo hacerlo, indica paso a paso como crear un servicio en Android que se ejecute al iniciar el sistema. Como sabemos, un servicio es un proceso que se ejecuta en background aun cuando ningún componente visual de nuestra aplicación se encuentre activo.

La idea es más o menos sencilla: una vez que un sistema Android ha iniciado envía una acción broadcast llamada android.intent.action.BOOT_COMPLETED. La idea es crear un BroadcastReceiver que escuche este tipo de acciones e inicie el servicio que deseemos. Así pues, el primer paso es crear una clase que extienda BroadcastReceiver:

public class Recibidor extends BroadcastReceiver{
	@Override
	public void onReceive(Context context, Intent intent) {
		Intent servicio = new Intent();
		servicio.setAction("foo.bar.Servicio");
		context.startService(servicio);
	}
}

Lo interesante aquí es que se ejecuta el método startService enviando como parámetro un Intent cuyo action es “foo.bar.Servicio”, el cual es el servicio que deseamos ejecutar. Dicho servicio es una clase que extiende de Service, y del cual debemos sobrescribir los métodos onCreate y onStart:

public class Servicio extends Service{

	private static final String TAG = "EjemploServicioBoot";

	private Timer timer;

	@Override
	public IBinder onBind(Intent intent) {
		return null;
	}

	@Override
	public void onCreate(){
		super.onCreate();
		Log.d(TAG, "Servicio creado");
		timer = new Timer();
	}

	@Override
	public void onStart(final Intent intent, final int startId){
		super.onStart(intent, startId);
		timer.scheduleAtFixedRate(new TimerTask() {
			@Override
			public void run() {
				Log.i(TAG, "Se ejecuta la tarea");
			}
		}, 0, 15000);
	}
}

En este caso, el servicio realiza una tarea muy simple: imprime en el log del sistema un mensaje. Básicamente tenemos un objeto tipo Timer que ejecutará una tarea; en onCreate simplemente iniciamos el objeto Timer, mientras que en onStart usamos el método scheduleAtFixedRate indicando que ejecutaremos dicha tarea cada 15 segundos.

Por último, debemos registrar en el archivo AndroidManifest.xml el BroadcastReceiver y el servicio:

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
      package="foo.bar" android:versionCode="1" android:versionName="1.0">
    <application>
        <service android:name=".Servicio">
        	<intent-filter>
        		<action android:name="foo.bar.Servicio"/>
        	</intent-filter>
        </service>
        <receiver android:name=".Recibidor">
        	<intent-filter>
        		<action android:name="android.intent.action.BOOT_COMPLETED"/>
        	</intent-filter>
        </receiver>
    </application>
    <uses-sdk android:minSdkVersion="3" />
    <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" />
</manifest>

En el manifest podemos ver que añadimos un elemento service dentro de application, para registrar nuestro servicio. Y lo más interesante se ve en las líneas 12 y 17, que es donde indicamos el tipo de mensaje que nuestro recibidor estará esperando antes de ejecutar la tarea e indicamos que la aplicación requiere permisos para conocer cuando el boot del sistema a finalizado.

Descargar código fuente

Mark Murhpy es uno de los personajes más conocidos en el mundo de Android y el autor de 4 excelentes libros: The Busy Coder’s Guide to Android Development, The Busy Coders Guide to Advanced Android Development, Android Programming Tutorials y Android Beyond Java. El valor de los cuatro libros es de $40 USD, el cual es un precio bastante bajo para la calidad de los mismos.

Los ejemplos utilizados en los libros pueden ser descargados gratuitamente en el repositorio de Github. Además de esto, Mark es un usuario activo de StackOverflow.com… ¿y qué con eso? Bueno, personalmente me ha resuelto bastantes dudas allí (¿qué mejor que tener un experto dispuesto a solucionarte dudas puntuales?). También se le ve en twitter por si lo quieren seguir

En fin… Mark me ha enviado un cupón que permite subscribirse a su librería virtual por seis meses, y con la cual se puede acceder legalmente a todos sus contenidos. Los libros son actualizados regularmente cada mes o cada que sale una nueva versión del SDK. Además son distribuidos en formato PDF, EPUB o MOBI…

Así que pensé en sortear dicho cupón entre los lectores del blog que quisieran iniciarse en el mundo de Android (o que ya tengan experiencia pero quieran tener una referencia avanzada más directa). La verdad no sé que tanto pueda interesar a los lectores del blog el sorteo, pues no todos los que lo leen están interesados en la programación, pero no puedo dejar de compartir este valioso recurso con ustedes (tener en cuenta además que los libros están en inglés, por supuesto).

Así pues, si está interesado en adquirir estos títulos puede dejar un comentario indicando su interés, y si fuese posible la razón principal por la que desea aprender a desarrollar en esta plataforma (quisiera que el cupón se lo ganara alguien que realmente desea aprender del tema). El sorteo se realizará usando random.org (como habitualmente se hace) el día 2 de Julio (en honor al gran Andrés Escobar… bueno, en realidad es coincidencia pero sí le tenía bastante aprecio).

Esta receta es bastante simple para reproducir clips de audio en Android. Basta con usar el método create(context, int) de la clase MediaPlayer, pasándole como parámetro el actividad que desde donde se reproduce el sonido y la referencia al archivo de audio a reproducir. Tan sencillo como esto:

import android.app.Activity;
import android.media.MediaPlayer;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;

public class TestSonido extends Activity {
	@Override
	public void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.main);
		Button boton = (Button) findViewById(R.id.reproducir);
		boton.setOnClickListener(new View.OnClickListener() {
			@Override
			public void onClick(View v) {
				MediaPlayer mp = MediaPlayer.create(TestSonido.this, R.raw.slayer);
				mp.start();
			}
		});
	}
}

En este caso, R.raw.slayer representa un archivo de audio con nombre “slayer.mp3″ almacenado en la carpeta res/raw y el sonido se reproduce al presionar el botón con id reproducir.

Este tip sirve para hacer que las aplicaciones no tengan el comportamiento habitual: cargarse y modificarse según la posición del dispositivo; sino hacer que siempre la orientación sea la misma. Esto es útil por ejemplo al momento de crear video juegos, en donde muchas veces es mejor mostrar todo horizontalmente para aprovechar mejor la pantalla.

Para ello solo debemos agregar un par de atributos al XML de la actividad:

<activity android:name=".NombreActividad"
                  android:label="el label"
                  android:screenOrientation="landscape"
                  android:configChanges="orientation">
    <intent-filter>
        <action android:name="android.intent.action.MAIN" />
        <category android:name="android.intent.category.LAUNCHER" />
    </intent-filter>
</activity>

Se puede también poner android:screenOrientation="portrait" para que sea siempre vertical.

Tip rápido para crear aplicaciones que ocupen toda la pantalla y no tengan barra de titulo. Para quitar la barra de título se invoca el método requestWindowFeature con el parámetro Window.FEATURE_NO_TITLE; para hacer que la aplicación aparezca en pantalla completa se invoca el método setFlags de la ventana, enviándole el parámetro WindowManager.LayoutParams.FLAG_FULLSCREEN:

import android.app.Activity;
import android.os.Bundle;
import android.view.Window;
import android.view.WindowManager;

public class NombreActividad extends Activity {
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        requestWindowFeature(Window.FEATURE_NO_TITLE);
        getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,
        		WindowManager.LayoutParams.FLAG_FULLSCREEN);
        setContentView(R.layout.main);
    }
}

Cuando estamos creando interfaces gráficas en Android y la actividad en donde tenemos dicha interfaz es demasiado larga, Android no pone por defecto un scroll que permita navegar entre dicha interfaz. Para hacerlo, podemos usar la clase ScrollView:

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
	android:orientation="vertical" android:layout_width="fill_parent"
	android:layout_height="fill_parent">
	<TextView android:layout_width="fill_parent"
		android:layout_height="wrap_content" android:text="Un formulario muy largo"
		android:textSize="20dp" android:textColor="#ED0034" />
	<!-- inicia el ScrollView -->
	<ScrollView android:layout_width="fill_parent"
		android:layout_height="fill_parent">
		<!-- se colocal el LinearLayout que contendra el formulario -->
		<LinearLayout android:orientation="vertical"
			android:layout_width="fill_parent" android:layout_height="fill_parent">
			<TextView android:text="Nombre" android:layout_width="fill_parent"
				android:layout_height="wrap_content" />
			<EditText android:layout_width="fill_parent"
				android:layout_height="wrap_content" />
			<TextView android:text="Apellido" android:layout_width="fill_parent"
				android:layout_height="wrap_content" />
			<EditText android:layout_width="fill_parent"
				android:layout_height="wrap_content" />
			<TextView android:text="Dirección" android:layout_width="fill_parent"
				android:layout_height="wrap_content" />
			<EditText android:layout_width="fill_parent"
				android:layout_height="wrap_content" />
			<TextView android:text="Teléfono" android:layout_width="fill_parent"
				android:layout_height="wrap_content" />
			<EditText android:layout_width="fill_parent"
				android:layout_height="wrap_content" />
			<TextView android:text="e-mail" android:layout_width="fill_parent"
				android:layout_height="wrap_content" />
			<EditText android:layout_width="fill_parent"
				android:layout_height="wrap_content" />
			<TextView android:text="twiter" android:layout_width="fill_parent"
				android:layout_height="wrap_content" />
			<EditText android:layout_width="fill_parent"
				android:layout_height="wrap_content" />
			<TextView android:text="País" android:layout_width="fill_parent"
				android:layout_height="wrap_content" />
			<EditText android:layout_width="fill_parent"
				android:layout_height="wrap_content" />
			<TextView android:text="Ciudad" android:layout_width="fill_parent"
				android:layout_height="wrap_content" />
			<EditText android:layout_width="fill_parent"
				android:layout_height="wrap_content" />
		</LinearLayout>
	</ScrollView>
</LinearLayout>

Es importante tener en cuenta que dentro de un componente de tipo ScrollView se debe poner UN, y SOLAMENTE UN, componente, en este caso un LinearLayout.  Además, solo soporta scroll vertical. El resultado es algo  como esto:

En este caso he dejado un TextView por fuera del scroll de tal manera que aparezca siempre… pero por supuesto podemos hacer que el scroll ocupe toda la pantalla.

Descargar código fuente ejemplo

En esta entrada vamos a introducirnos en el desarrollo de interfaces gráficas para Android. Haremos un sencillo ejemplo paso a paso en donde la idea es que comprenda la filosofía con la que se trabaja al usar widgets y actividades. El resultado será una aplicación sencilla que pide una cadena de texto al usuario y la invierte. Es importante que ya tengas configurado el SDK y el Eclipse como se explica en Introducción a la programación con Android; aprenderemos a usar labels, cajas de texto, botones y eventos

Puesto que es la primera entrada de este tipo, voy a explicar detalladamente cada paso. En las siguientes iré un poco más rápido. Así que, si ya tiene experiencia con Android tal vez se aburra un poco

0. Crear un nuevo proyecto

Abrimos Eclipse y creamos un nuevo proyecto para Android:

Configuramos el proyecto de tal manera que quede así:

En este caso estoy usando la versión 1.6 de Android, pero puede escoger la versión que concuerde con el dispositivo sobre el que desea probar la aplicación. Esto se explica con más detalle en Introducción a la programación con Android. Fíjese que no hemos creado ninguna actividad inicialmente (el checkbox Create Activity no está seleccionado); la idea es ver cómo se deben crear las actividades, los layouts con la interfaz gráfica, las clases que referencian a las actividades y la configuración del AndroidManifest.xml.

1. Crear y configurar una Actividad inicial

Creamos una clase dentro del paquete net.casidiablo.ejemplo:

Y en el asistente de creación de clases de Eclipse le damos como nombre EjemploInvertir. Clic en Finish y editamos la clase para que luzca así:

package net.casidiablo.ejemplo;
import android.app.Activity;
import android.os.Bundle;
public class EjemploInvertir extends Activity{
    @Override
    public void onCreate(Bundle b){
        super.onCreate(b);
        setContentView(R.layout.main);
    }
}

Lo que hemos hecho es extender la clase Activity y redefinir el método onCreate. Además, ejecutamos el método setContentView indicándole que usaremos el layout main.xml (Si tiene esta expresión en el rostro: es que no ha leído la entrada de introducción  Android).

Puesto que deseamos que esta actividad sea mostrada al momento de ejecutar la aplicación, debemos editar el archivo AndroidManifest.xml, que se encuentra en la raíz del proyecto. Al hacer doble clic sobre este, vemos que es posible editarlo usando una interfaz gráfica. Para añadir la actividad que acabamos de crear, hacemos clic en la pestaña inferior Application, y en la sección Application Nodes hacemos clic en Add… Allí seleccionamos Activity y hacemos clic en OK.

Ahora debemos configurar la actividad. En la parte derecha ha aparecido un formulario llamado Attributes for Activity, en donde podremos hacerlo. Lo más importante es el nombre de la actividad, el cual debe ser el nombre de la clase que acabamos de crear. Es posible usar el botón Browse… para buscar las actividades actualmente disponibles…

Una vez hayamos seleccionado o escrito el nombre de la clase, debemos añadirle un Intent; pero… ¿qué es un Intent ? Los componentes de una aplicación en Android se comunican a través de mensajes llamados Intents (objetos de la clase android.content.Intent). Se trata de una estructura de datos pasiva que contiene una descripción abstracta de una operación que será realizada, y se usa comúnmente para iniciar actividades Sí ya se, es algo confuso al principio, pero de momento no es demasiado importante (más información aquí). Para añadir el intent, seleccionamos la actividad que acabamos de crear y hacemos clic en el botón Add… Seleccionamos Intent Filter, hacemos clic en OK. Y ahora, dentro del Intent crearemos dos componentes un Action y un Category.

Un Action es un String que contiene el nombre de la acción a ser realizada. En este caso, el Action será android.intent.action.MAIN, el cual es usado para ejecutar la primera actividad de una aplicación. Entonces, seleccionamos el Intent Filter que acabamos de crear, y hacemos clic en Add… escogemos Action, clic en OK y escogemos el nombre del Action:

Category es un String que contiene información adicional acerca del tipo de componente que debería manipular el Intent. En este caso el Category que añadiremos será CATEGORY_LAUNCHER el cual indica que la actividad puede ser la principal (la que se ejecuta al iniciar la aplicación). Luego de añadir el Category veremos que queda así:

Hacemos clic en el icono de guardar en la barra de herramientas y listo También es posible editar el archivo AndroidManifest.xml a mano, lo cual pienso que es mucho más rápido. Pero no esta de más saber cómo hacerlo con la interfaz gráfica Si abrimos el archivo con el editor de XML veremos:

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="net.casidiablo.ejemplo" android:versionCode="1"
    android:versionName="1.0">
    <application android:icon="@drawable/icon" android:label="@string/app_name">
        <activity android:name="EjemploInvertir">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER"></category>
            </intent-filter>
        </activity>
    </application>
    <uses-sdk android:minSdkVersion="4" />
</manifest>

Ahora que hemos configurado el AndroidManifest.xml podemos hacer una prueba de ejecución del programa… si todo va bien veremos algo como esto:

2. Crear la interfaz gráfica

En este paso, crearemos una nueva interfaz gráfica que contendrá un label, una caja de texto y un botón. Aprenderemos a posicionar/agrupar los elementos en la pantalla, y darles un tamaño adecuado. Vamos a crear un nuevo layout dentro del directorio res/layout/ (aunque podríamos haber usado el main.xml generado por asistente de Eclipse, pero prefiero que aprenda este proceso de una vez). Así que, hacemos clic en el botón de creación de nuevos archivos XML de Android:

Seleccionamos la opción layout y le damos un nombre al archivo. Por ejemplo, interfaz_grafica.xml:

¡Hacemos clic en Finish y listo! Al hacer doble clic sobre el archivo que acabamos de crear vemos que es posible editarlo usando una interfaz gráfica, pero en este caso usaremos el editor de XML, ya que es mucho más rápido hacerlo así Hacemos clic en la pestaña inferior que tiene el nombre del archivo (interfaz_grafica.xml) y veremos algo como esto:

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
 android:layout_width="wrap_content"
 android:layout_height="wrap_content">
</LinearLayout>

Por defecto se crea un objeto LinearLayout que contiene contiene tres parámetros: un XML Name Space (en este caso http://schemas.android.com/apk/res/android), el tamaño que ocupará a lo ancho y el que ocupará a lo largo. Para estos dos ultimos parámetros se está usando wrap_content indicando que se debe usar el menor espacio posible. Los objetos LinearLayout funcionan de manera similar a los JPanel de Java, pudiendo “contener” widgets de Android (labels, botones, menus u otros LinearLayout, etc.).

Lo siguiente será crear la interfaz gráfica para nuestro programa de ejemplo, pero antes vamos a aprender un poco sobre el directorio res/values Por defecto veremos que hay un archivo llamado strings.xml que contiene pares nomber<=>valor. Este archivo es usado para almacenar todas las variables “estáticas” de la aplicación. Si bien su uso no es estrictamente obligatorio, si es recomendado y es bueno saber usarlo. Para nuestro ejemplo entonces, tenemos dos cadenas de texto que podrían ser estáticas: el texto que aparecerá en el label y el texto que aparecerá en el botón. Para la primera vamos a asignar el texto directamente en el XML de la interfaz gráfica, mientras que para el botón lo haremos usando el archivo strings.xml; lo hago de las dos maneras con el fin de que quede clara la diferencia entre ambos métodos.

Abrimos el archivo strings.xml, que se encuentra en el directorio res/values, para añadir una nueva cadena de texto que será usada por el botón de la aplicación. Solo debemos añadir algo como esto: <string name=”texto_boton”>Invertir!</string>, de tal manera que quede así:

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string name="hello">Hello World!</string>
    <string name="app_name">Ejemplo</string>
    <string name="texto_boton">Invertir!</string>
</resources>

Ahora sí, vamos a modificar el archivo interfaz_grafica.xml de tal manera que quede así:

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
     android:layout_width="fill_parent" android:layout_height="fill_parent"
     android:orientation="vertical">
    <LinearLayout android:orientation="horizontal"
     android:layout_width="fill_parent" android:layout_height="wrap_content">
        <TextView android:text="Palabra: " android:layout_width="wrap_content"
         android:layout_height="wrap_content" />
        <EditText android:id="@+id/cajaTexto" android:layout_width="fill_parent"
         android:layout_height="wrap_content" />
    </LinearLayout>
    <Button android="@+id/btnInvertir" android:layout_width="fill_parent"
     android:layout_height="wrap_content" android:text="@string/texto_boton"/>
</LinearLayout>

Veamos qué hemos hecho arriba:

• En la línea 3 podemos ver que cambiamos el ancho y alto del LinearLayout principal de tal manera que utilice toda la pantalla (usando fill_parent).
• Puesto que el LinearLayout contendrá otros objetos, debemos indicarle el sentido en el que los irá poniendo. En este caso se deben poner verticalmente (android:orientation="vertical").
• En las líneas 5 y 6 creamos un nuevo LinearLayout que contendrá el label y la caja de texto. Puesto que queremos que estos dos objetos aparezcan en una sola línea, ponemos el parámetro android:orientation="horizontal". Además, le indicamos que ocupe toda la pantalla a lo ancho, pero que la altura sea la más pequeña posible.
• En las líneas 7 y 8 creamos un nuevo TextView (un label) con el texto “Palabra: “; esto lo indicamos con la propiedad android:text. Además queremos que ocupe el menor espacio posible tanto en alto como en ancho (wrap_content para layout_width y layout_height).
• En las líneas 9 y 10 creamos un EditText (una caja de texto), que es donde el usuario pondrá la palabra que desea invertir. Intentará ocupar el mayor ancho posible en la pantalla. Además, puesto que este es un objeto del cual necesitaremos datos, debemos asignarle un ID para que podamos acceder a él desde el programa en Java que crearemos en breve.
• En la línea 11 cerramos el LinearLayout que contiene el label y la caja de texto.
• En las líneas 12 y 13 creamos un objeto Button. Este objeto también tiene un ID puesto que debemos obtener una referencia del mismo desde el programa en Java. Además, a la propiedad android:text se está asignando @string/texto_boton que es la referencia a la variable que creamos en el strings.xml

Ahora que hemos creado la interfaz gráfica, vamos a ejecutar la aplicación para ver si ha quedado bien. Pero antes, debemos indicarle a nuestra Actividad que el layout que debe ejecutar es interfaz_grafica.xml. Esto lo hacemos modificando la clase EjemploInvertir.java para que quede así:

package net.casidiablo.ejemplo;
import android.app.Activity;
import android.os.Bundle;
public class EjemploInvertir extends Activity{
    @Override
    public void onCreate(Bundle b){
        super.onCreate(b);
        setContentView(R.layout.interfaz_grafica);
    }
}

Si todo va bien, al ejecutar la aplicación veremos algo como esto:

3. Programación de objetos de la interfaz gráfica

Ahora que hemos construido la interfaz gráfica, debemos programar la parte de “invertir la cadena de texto”. Para ello necesitamos extraer el texto que se ponga en la caja de texto y manejar los eventos que genera el botón; en cualquier caso, necesitamos referencias a dichos objetos. Así que, de momento, vamos a hacer que nuestra clase EjemploInvertir.java luzca así:

package net.casidiablo.ejemplo;
import android.app.Activity;
import android.os.Bundle;
import android.widget.Button;
import android.widget.EditText;
public class EjemploInvertir extends Activity{
    //declarar objetos
    private EditText texto;
    private Button boton;
    @Override
    public void onCreate(Bundle b){
        super.onCreate(b);
        setContentView(R.layout.interfaz_grafica);
        //iniciar los objetos
        texto = (EditText) findViewById(R.id.cajaTexto);
        boton = (Button) findViewById(R.id.btnInvertir);
    }
}

Veamos qué ha pasado allá arriba

• En las líneas 4 y 5 importamos las clases Button y EditText del paquete android.widget.
• En las líneas 9 y 10 declaramos objetos de tipo EditText y Button, los cuales los usaremos para manipular los que hemos creado en la interfaz gráfica.
• En la líneas 17 iniciamos el objeto EditTexto usando el método findViewById, a la cual le enviamos como parámetro el ID de la caja de texto (¿recuerdas? pusimos esto dentro del XML: android:id="@+id/cajaTexto").
• De igual manera creamos el objeto botón usando el ID btnInvertir que definimos en el XML.

Hasta el momento solo hemos creado los objetos, pero no estamos haciendo nada con ellos. Para esto, vamos a asignar un listener al botón, que ejecutará ciertas acciones al momento de presionarlo. Esto lo hacemos con el método setOnClickListener el cual recibe como parámetro un objeto de tipo android.view.View.OnClickListener. Veamos cómo debe quedar la clase y luego explico cada componente nuevo:

package net.casidiablo.ejemplo;
import android.app.Activity;
import android.os.Bundle;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.EditText;
import android.widget.Toast;
public class EjemploInvertir extends Activity{
	//declarar objetos
	private EditText cajaDeTexto;
	private Button boton;
	@Override
	public void onCreate(Bundle b){
		super.onCreate(b);
		setContentView(R.layout.interfaz_grafica);
		//iniciar los objetos
		cajaDeTexto = (EditText) findViewById(R.id.cajaTexto);
		boton = (Button) findViewById(R.id.btnInvertir);
		boton.setOnClickListener(new OnClickListener() {
			@Override
			public void onClick(View v) {
				invertir();
			}
		});
	}
	//metodo para invertir el texto
	private void invertir(){
		//obtener el string de la caja de texto
		String txt = cajaDeTexto.getText().toString();
		//verificar que haya texto por invertir
		if(!txt.equals("")){
			//invertir texto
			String resultado = "";
			for (int i = txt.length()-1; i>=0; i--)
				resultado += txt.charAt (i);
		    //asignamos el string invertido a la caja de texto
			cajaDeTexto.setText(resultado);
		}
		else Toast.makeText(this, "No hay nada que invertir", Toast.LENGTH_LONG).show();
	}
}

Veamos que fue todo eso…

• En la línea 5 se importan la interfaz OnClickListener. Dicha interfaz es usada en la línea 20 al crear un objeto que se enviará como parámetro al método setOnClickListener. Dentro, es necesario implementar el método onClick en donde pondremos las instrucciones que serán ejecutadas al momento de hacer clic en el botón (en este caso una llamada a la función invertir(), líneas 28 a 41).
• El método invertir inicia una variable String con los datos que contenga la caja de texto, usando el método getText de la clase EditText.
• En las líneas 35 y 36 se invierte la cadena, que posteriormente se pone de nuevo en la caja de texto usando el método setText (línea 38).
• En la línea 40 mostramos un mensaje usando la clase Toast. Este mensaje aparece cuando no hay datos en la caja de texto. Lo he colocado puesto que es bastante sencillo de implementar. Basta con usar el método estático makeText pasándole como parámetros el contexto en el que se mostrará (se usa this, puesto que se mostrará en la Actividad actual), el texto a mostrar y cuanto tiempo durará el mensaje.

Al ejecutar la aplicación, escribir “Estoy invertido” en la caja de texto y presionar el botón, veremos algo así:

Si no ponemos texto y presionamos el botón Invertir, veremos:

La aplicación está lista para ser probada en un dispositivo real. En mi caso la instalé en una HTC Tattoo y se ve así:

4. Descargar código

Este es el código fuente usado para este tutorial, espero le haya gustado. Cualquier duda o sugerencia no dude en comentarla.

Descargar Proyecto Eclipse

Esta pequeña entrada servirá como base para las siguientes, en las que iré poniendo mis experiencias con Android, un estupendo sistema operativo para dispositivos móviles basado en Linux, y que nos proporciona un completo SDK para desarrollar nuestras propias aplicaciones de una manera rápida y divertida.

Aprenderemos a instalar/configurar el SDK y el plugin para Eclipse.  Haremos el típico Hola Mundo, y explicaré un poco sobre la metodología de programación para esta plataforma (que es sobre Java). ¡Manos a la obra!

1. Instalar y configurar el SDK de android

Vamos a la página del Android SDK y descargamos la versión para nuestro sistema operativo. Yo uso Gentoo Linux, pero los pasos son prácticamente idénticos en Windows y en Mac. La última versión al escribir esta entrada es android-sdk_r05. Una vez que hayamos descargado el archivo, lo descomprimimos, entramos a la carpeta que se crea y ejecutamos (en Linux):

En Windows:

Veremos algo como esto:

Hacemos clic en Available packages y desplegamos el árbol que aparece bajo Sites, Packages and Archives para instalar el API sobre la(s) que deseamos trabajar, y una vez la(s) hayamos seleccionado hacemos clic en Install Selected. En este caso he seleccionado el API 7 (para la versión 2.1 de Android), la documentación del API 7, los ejemplos del API 7 y el SDK del API 4 (para la versión 1.6 de Android). Es importante elegir las APIs adecuadas teniendo el cuenta el tipo de dispositivo para el que estamos desarrollando la aplicación. Escogí en este caso el API 4 puesto que el equipo sobre el que pruebo los programas (HTC Tattoo) viene con Android 1.6 (Donut) [más información sobre las versiones y sus codenames]. Por supuesto, si desarrollas con el API 4 tus programas tienen un 98% de probabilidades de correr sobre las versiones más recientes de Android sin modificación alguna.

Una vez haya terminado de descargar e instalar las APIs podemos crear un dispositivo virtual sobre el que probaremos nuestras aplicaciones. Hacemos clic en Virtual Devices al lado izquierdo, luego sobre el botón New… y configuramos el dispositivo:

Como puede apreciar en la imagen de arriba, debe poner un nombre al dispositivo, seleccionar el API sobre el que va a trabajar, darle un tamaño a la memoria ROM, escoger un tipo de pantalla y algunas configuraciones avanzadas que no se tratarán en este tutorial. Una vez tengamos esto, hacemos clic en Create AVD y si todo sale bien veremos algo como esto:

2. Instalar y configurar el plugin para Eclipse

Para este paso, necesitaremos Eclipse 3.5 (Galileo, recomendado) o 3.4. Abrimos eclipse, vamos a la Window -> Install New Software…

Hacemos clic en el botón Add… para añadir el repositorio de Android (https://dl-ssl.google.com/android/eclipse/):

Clic en OK y ahora seleccionamos los plugins a instalar, y seguimos el proceso de instalación:

Una vez instalado, reiniciamos Eclipse y veremos que se han añadido algunos iconos extra en la barra de herramientas, y que además podemos crear proyectos para Android

3. Hola Mundo en Android

Ahora vamos a crear un nuevo proyecto y aprender un poco más sobre cómo funcionan las aplicaciones para Android.  Hacemos clic en el botón de creación de proyectos Android (o File… -> New Project -> Android Proyect):

Veremos el asistente de creación de proyectos para Android en donde debemos especificar: el nombre del proyecto (HolaParce), el API para el que vamos a desarrollar (1.6 en este caso), el nombre de la aplicación (Hola Parce en este caso), el nombre del paquete (se recomienda que sea un paquete nombrado con el estándar de Java, es decir, un dominio invertido), seleccionamos Create Activity y le damos un nombre (que cumpla las especificaciones de un nombre de clase en Java), y por último seleccionamos la versión mínima del API que deberán tener los dispositivos que corran nuestro aplicativo:

¡Clic en Finish y listo! Ahora podemos probar la aplicación… hacemos clic derecho sobre el Proyecto, seleccionamos Run as… -> Android Application. Se cargará el emulador y después de un par de minutos podremos ver nuestra aplicación:

4. Entendiendo el funcionamiento básico de las aplicaciones en Android

Las aplicaciones en Android funcionan bajo el esquema de “Actividades”. Una actividad presenta una interfaz gráfica (escrita en XML) que permite al usuario interactuar con la aplicación. Cada aplicación tiene varias actividades que se van mostrando al usuario según este las vaya necesitando. Una actividad llama a otra cuando sea necesario, y cada una de las actividades que se vayan mostrando se almacenan en una pila; es decir, cada vez que la aplicación lo requiera inserta una nueva actividad en la pila y, cuando esta ya no se necesite, se hace un push sobre esta lo cual deja en descubierto la actividad que estaba debajo. Importante leer esto para tener claro cada uno de los aspectos fundamentales de las aplicaciones Android.

Ahora, veremos detalladamente qué ocurrió en los pasos que seguimos arriba. Por ejemplo, al crear el proyecto se generan algunos archivos automáticamente. Veamos que hace cada uno de ellos…

Dentro del directorio res se han creado algunos subdirectorios:

• drawable-hdpi, drawable-mdpi, drawable-ldpi en donde se almacenan las imágenes que va a utilizar nuestra aplicación. La diferencia entre ellas es que debemos colocar las imágenes que aparecerán según el tipo de pantalla del dispositivo. En drawable-hdpi se colocarán las imágenes para dispositivos con alta resolución (High) y en drawable-ldpi (Low) pondremos las imágenes para dispositivos con pantallas pequeñas.
• values contiene inicialmente el archivo strings.xml, que es donde declaramos las cadenas de texto que usará nuestra aplicación. No es obligatorio definir todas las cadenas de texto allí, pero es bastante recomendable hacerlo. En este caso simplemente contiene la definición de una cadena de texto (llamada hello), que es la que se muestra al ejecutar la aplicación:

  <?xml version="1.0" encoding="utf-8"?>
  <resources>
   <string name="hello">Hello World, HolaParce!</string>
   <string name="app_name">Hola Parce</string>
  </resources>
  

• layout contiene los archivos XML que representan interfaces gráficas. Si echamos un vistazo al archivo generado (main.xml) veremos algo como esto:

  <?xml version="1.0" encoding="utf-8"?>
  <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
   android:orientation="vertical"
   android:layout_width="fill_parent"
   android:layout_height="fill_parent"
   >
  <TextView
   android:layout_width="fill_parent"
   android:layout_height="wrap_content"
   android:text="@string/hello"
   />
  </LinearLayout>
  

  De aquí podemos resaltar varias cosas:

  • Los layouts son XML estrictos, así que deben comenzar con el encabezado <?xml version="1.0" encoding="utf-8"?> y todas las etiquetas abiertas deben ser debidamente cerradas.
  • Los LinearLayout representan contenedores de widgets (algo similar al JPanel de swing en Java). Es decir, es la manera de organizar cada grupo de elementos de la interfaz gráfica.
  • En este caso, dentro del contenedor solo tenemos un TextView (que sería algo así como un JLabel de swing en Java).
  • Sea cual sea el elemento que pongamos en el layout, debemos especificar su anchura (android:layout_width) y altura (android:layout_height). Para cada parámetro podemos usar el valor fill_parent o wrap_content. fill_parent hará que el widget ocupe todo el tamaño posible, mientras que wrap_content hará que ocupe el menos posible.
  • El parámetro android:text permite asignar un texto al TextView. En este caso se usa @string/hello que indica que se usará una variable llamada hello. Esta variable puede ser encontrada en el archivo strings.xml dentro del directorio values. También podríamos especificar el texto directamente, por ejemplo: android:text="Hola parcero!"
• Como tal vez se dio cuenta, es posible editar los archivos XML gráficamente o con el editor de textos de Eclipse.

Dentro del directorio gen se encuentra un archivo llamado R.java. Este archivo NO debemos modificarlo ya que es Eclipse quien se encargar de poner el código allí dentro. Este archivo sirve básicamente para enlazar las cosas que hagamos en XML con la programación en Java. Por ejemplo, se crea una referencia a la variable hello creada en el archivo strings.xml. Esto permite que podamos referenciar dicha variable desde Java (esto se explica con más detalle abajo).

Bajo el directorio src se creó un paquete y dentro de él un archivo en Java que es nuestra primera actividad (fíjese cómo la clase creada extiende la clase Activity del paquete android.app):

package net.casidiablo.holaparce;
import android.app.Activity;
import android.os.Bundle;
public class HolaParce extends Activity {
/** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
    }
}

Veamos en detalle cada línea:

• Línea 1 define el nombre del paquete.
• Líneas 2 y 3 importamos las clases que necesitamos para correr la actividad.
• En la línea 4 podemos ver que la clase exitiende a Activity.
• En la línea 7 redefinimos el método onCreate de la clase Activity, el cual es ejecutado al momento de iniciar la aplicación. Note que no es necesario tener un método main; en Android se define una actividad principal que será ejecutada al iniciar la aplicación (más adelante veremos donde se configura esto).
• En la línea 9 se usa el método setContentView que define cual de las interfaces gráficas creadas en el directorio layout serán usadas. Como parámetro usamos la variable R.layout.main. Esto es algo confuso al principio así que lea atentamente: R, como vimos anteriormente, es una clase generada por Eclipse automáticamente cada vez que creamos nuevos componentes para la aplicación; dentro de ella se crean clases estáticas con variables enteras que representan cada uno de estos componentes (main.xml es entonces una variable entera llamada main, dentro de la clase estática layout, que a su vez se encuentra dentro de la clase R.java). Por ejemplo, para usar la variable hello desde Java, tendríamos que usar una referencia de tipo R.values.hello.

Por último, tenemos el archivo AndroidManifest.xml. Todas las aplicaciones deben tener este archivo y no debe ser renombrado. En él se especifican las opciones generales del programa, como el paquete principal, la actividad que deberá ejecutarse al iniciar la aplicación (y deben incluirse allí TODAS las actividades que se van usar), el icono a usar, los permisos, etc.

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
 package="net.casidiablo.holaparce"
 android:versionCode="1"
 android:versionName="1.0">
 <application android:icon="@drawable/icon" android:label="@string/app_name">
 <activity android:name=".HolaParce"
 android:label="@string/app_name">
 <intent-filter>
 <action android:name="android.intent.action.MAIN" />
 <category android:name="android.intent.category.LAUNCHER" />
 </intent-filter>
 </activity>
</application>
 <uses-sdk android:minSdkVersion="4" />
</manifest>

5. Operaciones avanzadas: acceder al dispositivo por consola y obtener una shell

Como sabemos, Android está basado en Linux, y como tal posee una interfaz de linea de comandos que podemos acceder usando las herramientas del sdk. Esto lo podemos hacer tanto para dispositivos virtuales, como el de este ejemplo, como para dispositivos reales. En este caso lo haremos con el dispositivo virtual que creamos para el ejemplo. Es tan sencillo como ejecutar esto en consola (en Linux):

Lo que hacemos con el comando anterior es indicarle al adb que queremos abrir una shell del dispositivo con serial emulator5554. Para ver los dispositivos conectados actualmente y sus seriales usamos el comando adb devices. Si todo va bien veríamos algo como esto:

Desde dicha shell podemos hacer bastantes cosas, pero la más interesante para mi, es poder usar el SQLite3 para acceder a las bases de datos de las aplicaciones que creemos, lo cual nos permite una depuración mucho más rápida.

Eso es todo… espero les haya gustado. Cualquier comentario, duda o sugerencia no duden en comentarla.

6. Links interesantes y fuentes de información

• Sitio oficial de Android para desarrolladores (esta es prácticamente todo lo que vas a necesitar)
• xda-developers, comunidad de desarrolladores de Android y Windows Mobile

PHP posee una completa API para la manipulación de archivos XML. Sin embargo, algunas veces queremos hacer cosas muy simples y no vale la pena construir manualmente un script que sirva de parser de un archivo XML. En esos casos, podemos hacer uso de una función llamada xml2array.

La idea es bastante simple: le pasamos como argumento el string de un archivo XML y nos retorna un array asociativo con los datos del mismo. Los pasos son los siguientes:

0. Descargar la función

Lo primero es descargar la función de aquí. Copias el código PHP y lo pones en un archivo con nombre xml2array.php

1. Ejecutar la función [ejemplo]

Debemos usar la función file_get_contents para obtener el string con el XML que pasaremos como parámetro a la función. Suponiendo que tenemos este archivo XML:

<?xml version="1.0" encoding="iso-8859-1"?>
<distros type="linux">
    <nombre id="1">Gentoo</nombre>
    <nombre id="2">Arch</nombre>
    <nombre id="3">Exherbo</nombre>
</distros>

Podríamos usar xml2array así:

<?php
require("xml2array.php");
$contenido = file_get_contents('datos.xml');
$resultado = xml2array($contenido);
var_dump($resultado);
?>

El resultado sería el dump del array:

array(2) {
  ["distros"]=>
  array(1) {
    ["nombre"]=>
    array(6) {
      [0]=>
      string(6) "Gentoo"
      [1]=>
      string(4) "Arch"
      ["0_attr"]=>
      array(1) {
        ["id"]=>
        string(1) "1"
      }
      ["1_attr"]=>
      array(1) {
        ["id"]=>
        string(1) "2"
      }
      [2]=>
      string(7) "Exherbo"
      ["2_attr"]=>
      array(1) {
        ["id"]=>
        string(1) "3"
      }
    }
  }
  ["distros_attr"]=>
  array(1) {
    ["type"]=>
    string(5) "linux"
  }
}

Veamos un ejemplo un poco más avanzado. Vamos a procesar un documento XML que proporciona Mercado Libre con productos a la venta; además vamos a mostrar un listado HTML con dichos productos:

<?php
require("xml2array.php");
$contenido = file_get_contents('http://www.mercadolibre.com.co/jm/searchXml?as_categ_id=1648');
$resultado = xml2array($contenido);
$items = $resultado['response']['listing']['items']['item'];
foreach($items as $item)
    if(isset($item['title'])){
        echo "<p><a href='{$item['link']}'>";
        echo "<img src='{$item['image_url']}'/><br/>";
        echo "<b>{$item['title']}</b></a><br>";
        echo "<em>{$item['subtitle']}</em><br>";
        echo "<em>{$item['currency']}</em> {$item['price']}</p>";
    }
?>

Ejecutando el ejemplo anterior obtendremos algo como lo siguiente:

Descarga de los ejemplos

Puedes descargar los archivos usados en los ejemplos anteriores. Ten en cuenta que la versión de la función que está en la descarga es la última a la fecha (1 de febrero de 2010). Aunque funciona muy bien, los autores tienden a actualizarla, así que podrías echar un vistazo a la página oficial en busca de nuevas versiones.

Descargar código fuente