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

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

Seam es un proyecto desarrollado por JBoss, cuyo lider es Gavin King. Es un completo framework para la creación de aplicaciones web 2.0 que unifica varias tecnologías como AJAX, Enterprise Java Beans (EJB3), Java Server Faces (JSF), Java Portlets and Business Process Management (BPM), Hibernate, y mucho más.

De la Wikipedia:

Seam introduce el concepto de contextos. Cada componente de Seam existe dentro de un contexto. El contexto conversacional por ejemplo captura todas las acciones del usuario hasta que éste sale del sistema o cierra el navegador – inclusive puede llevar un control de múltiples pestañas y mantiene un comportamiento consistente cuando se usa el botón de regresar de el navegador.

Tú puedes automáticamente generar una aplicación web de altas, bajas, cambio y modificaciones a partir de una base de datos existente utilizando una herramienta de linea de comandos llamada seam-gen incluida con el framework.

El desarrollo WYSIWYG es facilitado a través del uso de las JBoss Tools, que es un conjunto de plug-ins diseñados para el entorno integrado de desarrollo Eclipse. Seam puede ser integrado con las bibliotecas de componentes JSF JBoss RichFaces o con ICEsoft ICEFaces. Ambas bibliotecas poseen soporte para AJAX.

Actualmente soporta varios contenedores de aplicaciones como JBoss 4 o 5, IBM Websphere, BEA WebLogic, Oracle OC4J y por supuesto Apache Tomcat.

Puedes encontrar ejemplos de proyectos creados con seam y listos para ejecutar dentro del directorio examples de la aplicación.

Referencias y documentación:

• Página oficial de Seam Framework
• Página del producto JBoss Seam
• Documentación Online mantenida por la comunidad
• Documentación de JBoss Seam
• Introduction to JBoss Seam [artículo en InfoQ]

Laboratorio de JBoss Seam Framework

Con el siguiente laboratorio se pretende dar un punto de partida a la creación de aplicaciones usando Seam. El laboratorio está enfocado al desarrollo sobre Eclipse, que es el IDE que recomiendo para trabajar con Seam.

Este laboratorio está enfocado al uso de Seam para JBoss, aunque con pocas o sin modificaciones puede funcionar en Apache Tomcat. Recordemos además que Seam también soporta los contenedores IBM Websphere, BEA WebLogic y Oracle OC4J.

Nota: todas las pruebas se realizaron sobre Linux (Gentoo amd64) y OpenSolaris 9.6. Sin embargo, hacerlo en Windows con los mismos pasos no debería presentar problemas; solo se debe tener cuidado con las rutas donde se guarden los archivos usados.

Prerequisitos

• Eclipse 3.4 o 3.5
• La última versión de JBoss Seam (la más reciente al momento de escribir este documento es la 2.2.0).
• La última versión de Jboss Server (la más reciente al momento de escribir este documento es la 5.1.0).
• Un gestor de bases de datos. En mi caso he usado MySQL, aunque hay soporte para muchos otros gestores. No olvides además descargar el conector JDBC, en mi caso el mysql-connector-java-bin.jar.

Instalación

Para instalar Seam y JBoss basta con descomprimir los paquetes que descarguemos de Internet. Yo recomiendo hacerlo en la carpeta /opt en sistemas UNIX/Linux, o directamente en C:/ en sistemas Windows.

Creación de un proyecto base para Eclipse

SeamFramework nos proporciona una herramienta de línea de comandos para la generación de proyectos base. Vamos al directorio donde lo instalamos y ejecutamos:

Ahora debemos responder a cada una de las preguntas que nos hace; muchas de ellas las debemos dejar por defecto, así que nos concentraremos solo en aquellas en donde tengamos que cambiar. Resumiendo:

• El directorio donde se creará el proyecto:
  [input] Enter the directory where you want the project to be created (should not contain spaces) [/home/funtoo/projects] [/home/funtoo/projects]
  /home/funtoo/Poli/Componentes/seam-framework/workspace
• El directorio donde se encuentra el JBoss AS:
  [input] Enter your JBoss AS home directory [C:/Program Files/jboss-5.1.0.GA] [C:/Program Files/jboss-5.1.0.GA]
  /opt/jboss-5.1.0.GA/
• El nombre del proyecto:
  [input] Enter the project name [myproject] [myproject]
  holaseam
• Vamos a desarrollar nuestra aplicación como EAR:
  [input] Is this project deployed as an EAR (with EJB components) or a WAR (with no EJB support)? [war] (ear, [war])
  ear
• Definimos el nombre del paquete en base de la aplicación:
  [input] Enter the base package name for your Java classes [com.mydomain.holaseam] [com.mydomain.holaseam]
  org.ejemplo.seam
• Los que hacen referencia a los Session Beans o Test Cases los podemos dejar como nos lo pongan. El gestor de base de datos; en este caso usé mysql aunque debería ser practicamente transparente:
  [input] What kind of database are you using? [hsql] ([hsql], mysql, derby, oracle, postgres, mssql, db2, sybase, enterprisedb, h2)
  mysql
• Ingresamos la ruta en donde se encuentra el driver JDBC:
  [input] Enter the filesystem path to the JDBC driver jar [] []
  /opt/conectores/mysql-connector-java-5.0.8-bin.jar
• Ahora debemos definir la URL de conexión a la base de datos. En este caso, he creado una base de datos llamada ejemplo, y por lo tanto la URL quedaría así:
  [input] Enter the JDBC URL for your database [jdbc:mysql:///test] [jdbc:mysql:///test]
  jdbc:mysql://localhost:3306/ejemplo
• Con esta opción se ejecutará un script llamado import.sql cada vez que hagamos un deploy del proyecto. Dicho archivo deberá tener los scripts necesarios para crear tablas y registros. Puesto que en este laboratorio poco vamos a usar MySQL, puedes poner lo que quieras; pero es importante tener en cuenta esta opción a la hora de desarrollar un proyecto.
  [input] Do you want to recreate the database tables and execute import.sql each time you deploy? [n] (y, [n])
  y

Ya que hemos configurado lo que será el proyecto, es hora de crearlo. Ejecutamos el comando:

Esto creará un proyecto base que puedes abrir con Eclipse, y eso es justo lo que haremos a continuación.

Abrimos eclipse y nos aseguramos que el workspace sea el mismo directorio en el que creamos el proyecto desde Seam. Vamos a la creación de un nuevo proyecto Java:

Le damos el mismo nombre que a nuestra aplicación Seam (en este caso holaseam):

Y puesto que ya existe un proyecto creado en el workspace muchas de las opciones ya aparecen asignadas. Hacemos clic en Next y vemos que ya hay una estructura de directorios creada con la base del proyecto Seam.

Hacemos clic en Finish, y ya podemos comenzar a editar y modificar el proyecto.

Despliegue del proyecto

Primero debemos iniciar el servicio de JBoss. Para ello ejecutamos el archivo run.sh (run.bat en Windows) del directorio bin de Jboss. Este dejará el servicio web corriendo por defecto en el puerto 8080.

Para hacer el despliegue sobre JBoss, usamos un archivo Ant que se generó junto con el proyecto. Dicho archivo nos permite ejecutar tests, hacer (re)despliegues, generar el JavaDoc, entre otras. Así que habrímos el archivo build.xml y nos aseguramos que la vista Outline esté abierta:

Dentro de la vista Outline podemos ver los componentes del archivo build.xml y podemos ejecutarlos con Ant. En este caso, buscamos el componente deploy, hacemos clic derecho, Run As, y Ant Build.

Algunas veces se generan errores al hacer el despliegue:

Si es tu caso, deberás eliminar los archivos y directorios que tengan el nombre del proyecto del directorio deploy en JBoss. En mi caso los elimino con este comando:

Si todo sale bien, cuando hagamos de nuevo deploy veremos algo como esto:

Es hora de probar la aplicación. Abrimos el navegador en la dirección: http://localhost:8080/holaseam/

Descargar versión en PDF

Descargar

En este pequeño manual explicare la manera de instalar Gentoo de una forma sencilla, simple, ilustrada y rápida, este proceso incluye instalación de Gentoo para x86 y AMD (32bits y 64bits), a su vez, puede también tomarse este manual como una opción alternativa a los manuales Oficiales de Gentoo…

Descargar [licencia cc]

Página del autor

Esta guía es la continuación de la anterior entrada, en donde explicaba cómo montar un servidor Git. Ahora veremos las operaciones básicas sobre el repositorio (hacer un checkout, añadir o borrar objetos, commit, etc.). Del lado del cliente también debemos tener instalado git:

En Debian:

En Gentoo:

Clonar el repositorio

Llamamos “clonar” a descargar los archivos fuentes de un repositorio git a un nuevo directorio. En este caso usaremos el método que usa SSH y el usuario que creamos en la entrada anterior.

Los archivos los añadimos normalmente, es decir, editándolos dentro del directorio del proyecto o copiándolos de otro lado. Por ejemplo:

Añadir archivos al repositorio

Antes de comenzar a añadir cosas o realizar cambios debemos actualizar el repositorio con respecto al del servidor:

Ahora añadiremos los archivos que hemos creado al repositorio:

o mejor aún:

Subir cambios al servidor local

Para subir los cambios hechos al servidor local (lease el comentario de CaStarCo):

Para subir los cambios al repositorio debemos ejecutar este comando:

Ver cambios entre versiones

Para ver los cambios entre la versión que tenías antes de hacer un git pull y la actual, puedes ejecutar el comando:

O puedes ver todos los cambios que ha sufrido el proyecto usando:

Puedes también consultar la guía oficial de Git para cosas más avanzadas.

¡Hola a todos! Ya que me encuentro haciendo un proyecto para la Universidad, he decidido esta vez probar Git y dejar a un lado mi querido Subversion. Git es básicamente un sistema de control de versiones, creado por Linus Torvalds, y es usado en proyectos grandes como el Kernel de Linux. Así que he preparado una pequeña guía de instalación y configuración de Git, además de la interfaz web del mismo, lo cual nos permite ver los cambios del proyecto de una manera más amena.

Para este mini proyecto he instalado el servidor en una máquina virtual corriendo Debian 5. El motivo de dejar mi Gentoo por un rato es porque ya es de madrugada y necesitaba que la instalación fuera más rápida; además no me gusta instalar cosas que más adelante no necesitaré: para eso está la virtualización. ¡Basta de rodeos, vamos al grano!

Instalando los paquetes necesarios

Instalaremos Apache2, la base de git y los módulos web de git (y el server de ssh para que los clientes se conecten):

Ahora creamos los directorios /var/cache/git (el repositorio git) y /var/www/git para el gitweb.cgi:

En nuestro ejemplo, el directorio raiz del apache es /var/www; ahora debemos crear un archivo de configuración de Apache para el git:

Ponemos lo siguiente adentro:

<Directory /var/www/git>
   Allow from all
   AllowOverride all
   Order allow,deny
   Options ExecCGI
   <Files gitweb.cgi>
   SetHandler cgi-script
   </Files>
</Directory>
DirectoryIndex gitweb.cgi
SetEnv  GITWEB_CONFIG  /etc/gitweb.conf

Ahora movemos los archivos gitweb.cgi, .png y .css de git a /var/www/git:

Debemos ahora hacer un par de cambios en el archivo /etc/gitweb.conf debido a los archivos que movimos:

$projectroot = '/var/cache/git/';
$git_temp = "/tmp";
#$home_link = $my_uri || "/";
$home_text = "indextext.html";
$projects_list = $projectroot;
$stylesheet = "/git/gitweb.css";
$logo = "/git/git-logo.png";
$favicon = "/git/git-favicon.png";

Recargamos la configuración del apache:

Iniciando un proyecto en Git

Creamos la carpeta del proyecto…

Iniciamos un repositorio para nuestro nuevo proyecto y lo configuramos de acuerdo a nuestras necesidades:

Para marcar un repositorio como exportado se usa el archivo git-daemon-export-ok:

Para iniciar el servicio de Git que ejecuta un servidor para hacer público nuestro repositorio, ejecutamos el siguiente comando (no debe haber un slash después de la ruta del repositorio):

Ahora el repositorio se encuentra corriendo en el puerto 9418 de nuestro computador. Por último, le daremos permisos de escritura a un usuario que no sea root, de tal manera que con dicho usuario se puedan hacer cambios remotos en el repositorio:

Acceder al repositorio

Para descargar el repositorio de la manera convencional, basta con ejecutar el comando:

O lo puedes acceder vía web; en mi caso el servidor está en la dirección 192.168.0.5, entonces basta con visitar http://192.168.0.5/git/:

Fuentes y enlaces interesantes

• Página oficial del proyecto
• Artículo guía de esta entrada
• Miniguia de Git

Esta entrada pretende profundizar los temas aprendidos en el anterior artículo (Tu primer módulo cargable para el Linux kernel), con el fin de clarificar dudas, atar algunos cabos que dejamos sueltos y prepararnos para los siguientes artículos.

¿Puedo usar directamente el árbol del código fuente del kernel?

Sí, por supuesto. Como ya sabes, no es posible compilar un módulo cargable sin al menos parte del código fuente del kernel – esto es, la parte que contiene la infraestructura de construcción general y los archivos de cabecera esenciales. Solo por recordar, un archivo header (con extensión .h), contiene, normalmente, una declaración directa de clases, subrutinas, variables, u otros identificadores; sin la definición de estas, no es posible compilar código que las use.

En cualquier caso, es siempre útil tener una copia completa del código del kernel, y la manera más fácil de obtenerla es usando git:

Además que puedes actualizarlo fácilmente:

Nótese que, al contrario de instalar el paquete oficial de desarrollo del kernel como hicimos en el anterior artículo, usando git no es necesario tener privilegios administrativos para poner todo el código en algún lugar de tu directorio home. Además, si por alguna razón no puedes usarlo, puedes descargarte un archivo tar y funcionará igual; claro, usar git es mucho más cool

Urgando en el código fuente: examinando los archivos de cabecera (Header Files)

Recordemos que en el ejemplo del artículo anterior, nuestro código contiene referencias a archivos de cabecera del kernel:

#include <linux/module.h>      // para todos los módulos
#include <linux/init.h>        // para entrada y salida de macros
#include <linux/kernel.h>      // para los macros de prioridad de printk
#include <asm/current.h>       // procesar información, solo por diversión
#include <linux/sched.h>       // para usa la estructura task_struct

Tales referencias son siempre relativas al nivel superior del directorio include/ en el código fuente del kernel, así que un include de, por ejemplo, <linux/module.h>, se refiere al archivo de cabecera include/linux/module.h, y así sucecivamente.

Sin embargo, si miras un poco más de cerca, notarás que no hay un directorio include/asm/, lo cual es bastante fácil solucionar. Incluso si no planeas construir algo contra el código fuente que descargaste, deberías prepararlo de tal manera que refleje de una manera más precisa lo que piensas hacer con él:

Los comandos anteriores hacen bastantes cosas, aunque lo único que nos interesa en este momento es que crea algunos enlaces simbólicos en el directorio include/, que reflejan la arquitectura de nuestro sistema.

Antes de ejecutar los comandos:

Después de ejecutarlos:

Una vez que esto es hecho, los includes de preprocesador tendrán sentido, y podemos usar los nombres genéricos para referirnos al archivo de cabecera apropiado de ahora en adelante. Por supuesto, esto que hicimos no es necesario hacerlo con los paquetes oficiales de desarrollo del kernel, puesto que ya vienen preparados.

¿Es posible generar mensajes de salida con un módulo?

No, no lo es. Bueno, no realmente. Como un autor de módulos novato, es necesario que entiendas que tu módulo será ejecutado en el kernel space, no en el user space, así que debes dejar de pensar en impresiones de mensajes en la consola. Olvídate de ello. La manera canónica de generar mensajes de depuración desde tu módulo es con llamadas printk:

printk(KERN_INFO "Hola, el modulo esta siendo cargado.\n");
printk(KERN_INFO "El user space del proceso es '%s'\n", current->comm);
printk(KERN_INFO "El PID es  %i\n", current->pid);  

Corriendo el riesgo de sobre-simplificar el asunto, la salida que genera printk acabará en el archivo /var/log/messages así que, si estás insertando y removiendo tu módulo, es útil tener una terminal aparte mostrando en tiempo real todo lo que sea escrito en dicho archivo (para lo cual necesitas privilegios administrativos):

Para los más ambiciosos, es útil fijarse en la definición de los niveles de log en el archivo de cabecera <linux/kernel.h>:

#define KERN_EMERG    "<0>"  /* system is unusable                 */
#define KERN_ALERT    "<1>"  /* action must be taken immediately   */
#define KERN_CRIT     "<2>"  /* critical conditions                */
#define KERN_ERR      "<3>"  /* error conditions                   */
#define KERN_WARNING  "<4>"  /* warning conditions                 */
#define KERN_NOTICE   "<5>"  /* normal but significant condition   */
#define KERN_INFO     "<6>"  /* informational                      */
#define KERN_DEBUG    "<7>"  /* debug-level messages               */

Si algunos de ellos lucen vagamente familiares, no es de sorprenderse – son los niveles de depuración (debugging) soportados por syslog, así que eres libre de personalizar el syslog si quieres redireccionar la salida de tu módulo a donde quieras basado en los niveles de log, lo cual está más allá del objetivo de este artículo.

printk(KERN_INFO "Hola, el modulo esta siendo cargado.\n");
printk("<6>" "Hola, el modulo esta siendo cargado.\n");
printk("<6>Hola, el modulo esta siendo cargado.\n");

Aun así, es mejor hacerlo como se muestra en la primera línea. Incluso programando cosas del kernel, la estética importa.

Cargando tu módulo lleno de información

Como te diste cuenta la última vez, puedes cargar tu módulo con información bastante útil como:

MODULE_AUTHOR("Robert P. J. Day");
MODULE_AUTHOR("Cristian Castiblanco [solo lo puse en castellano]");
MODULE_LICENSE("Dual BSD/GPL");
MODULE_DESCRIPTION("Aqui puedes poner una descripcion de tu modulo");

que puede examinarse con el comando modinfo:

$ sudo modinfo hola.ko
filename: hola.ko
description: Aqui puedes poner una descripcion de tu modulo
license: Dual BSD/GPL
author: Cristian Castiblanco [solo lo puse en castellano ]
author: Robert P. J. Day
depends:
vermagic: 2.6.29-gentoo-r5 SMP mod_unload CORE2

Algunas cosas útiles acerca de esta característica:

• El conjunto completo de estos macros está definido en el archivo de cabecera <linux/module.h>, en donde verás macros relacionados con firmware, tablas de dispositivos y más.
• Además de esos macros en específico, está el menos conocido macro genérico MODULE_INFO, el cual puedes usar dentro del módulo en el lugar que quieras. Curiosamente, muy pocos programadores toman ventaja de este.
• La única macro que realmente debes poner es la licencia. Si no especificas alguna de las variaciones de la licencia GPL, entonces el módulo “contaminará” el kernel, un tema que trataremos en otro artículo. El conjunto completo de licencias válidas está definido en el mismo archivo de cabecera.

Compilando contra el código fuente del kernel

Finalmente, podrías querer construir tu módulo, no contra el código instalado por el paquete de desarrollo, sino contra el código que descargaste tú mismo. Si ese es tu plan, es bastante simple.

Primero, como decíamos arriba, necesitas preparar tu código fuente para construir el módulo:

Todo lo que falta es configurar el Makefile de tal manera que compile el módulo contra nuestro código fuente. Recordemos parte del archivo Makefile del artículo anterior:

ifeq ($(KERNELRELEASE),)
KERNELDIR ?= /lib/modules/$(shell uname -r)/build
PWD := $(shell pwd)

Lo que hace la segunda línea es asignar la ubicación del código fuente del kernel a ser usado. Para cambiar esta variable, podemos asignarle el valor deseado con este comando:

y aquí es donde comienzas a notar algunas diferencias. Asumiendo que la versión del código que descargué es 2.6.31-rc1, esto es lo que sucede en mi sistema:

Puesto que estoy compilando contra un código fuente que no concuerda con el que estoy corriendo actualmente, pierdo la tabla de símbolos actual, pero la compilación funciona.

El comando modinfo también muestra el árbol contra el cual el módulo fue compilado:

$ sudo modinfo hola.ko
filename: hola.ko
description: Aqui puedes poner una descripcion de tu modulo
license: Dual BSD/GPL
author: Cristian Castiblanco [solo lo puse en castellano ]
author: Robert P. J. Day
depends:
vermagic: 2.6.31-rc1 SMP mod_unload 686

Ahora algunas preguntas capciosas – ¿es posible cargarlo? ¿no dará problemas por la versión? Eso depende de si el kernel que se está ejecutando fue configurado para permitir diferencias de versiones, y hay una manera rápida de comprobarlo. En mi Gentoo por ejemplo:

Mala suerte. Tal parece que el kernel no fue compilado con las opciones necesarias. Si miramos en el archivo /var/log/messages:

Por lo pronto entonces, de ahora en adelante, jugaremos un poco dentro de la seguridad que nos ofrece compilar contra el kernel que concuerda con la versión que corremos. No hay motivo para hacerlo más difícil de lo que debe ser. En el próximo artículo veremos algo acerca de las rutinas entry y exit.

Este how-to está basado en el artículo The Kernel Newbie Corner: Your First Loadable Kernel Module escrito por Rob Day en Linux.com. En él se enseñan las bases de la programación de módulos para el kernel de Linux. Este primer artículo pretende ilustrar de manera clara los conceptos básicos y espero que, a medida que Rob vaya escribiendo más artículos, pueda ir traduciéndolos para ofrecer este excelente contenido en español. Además, funciona para cualquier distro, aunque en este caso lo hice todo sobre Gentoo. Sin más, ¡vamos al grano!

¿Es necesario tener privilegios de root?

Mientras desarrollamos el módulo, no. Pero al momento de cargar el módulo necesitaremos privilegios administrativos. Por supuesto, es recomendable que el desarrollo lo hagamos con un usuario normal, y solo al final usemos un usuario root para cargar o remover los módulos.

Prerrequisitos

Antes de comenzar es necesario saber/tener algunas cosas:

• La versión del kernel con la que vamos a trabajar (usualmente la que estamos corriendo). Esto lo hacemos con el comando uname -r:
  $ uname -r
  2.6.29-gentoo-r5
• El uso de herramientas de desarrollo, como gcc, binutils, etc.
• Tener instalados las utilidades para trabajar con módulos (insmod, rmmod, etc.), el cual se encuentra en el paquete module-init-tools.
• El código del kernel de Linux, de tal manera que puedas compilar tu módulo contra este.

¿Para qué el código del kernel?

Esto es realmente importante, así que echaremos un vistazo un poco más profundo. Cuando compilamos un módulo para Linux es necesario tener el código fuente de algunas partes del kernel, puesto que muchas instrucciones de preprocesador usadas no se encuentran en los headers estándar de desarrollo. En vez de ello, se encuentran en los headers de kernel.

Podrías simplemente descargar el código del kernel directamente de la página oficial, aunque lo más sencillo es instalar el paquete que corresponda a la versión del kernel que estemos ejecutando. Por lo general, este tipo de paquetes instala el código en /usr/src o /usr/src/kernels. Por ejemplo, en Fedora el paquete que debes instalar se llama kernel-dev, mientras que en Gentoo es gentoo-sources.

Una vez tengas el código instalado, es necesario saber exactamente en donde se encuentra, de tal manera que podamos referenciarlo al momento de compilar el módulo. Podrías revisar eso manualmente o, mejor aún, buscar el enlace simbólico hacia el kernel, que por lo general se encuentra en /lib/modules:

El enlace simbólico que buscamos es build, y como puedes ver en el ejemplo, apunta a la raíz del código del kernel. Esto significa que, cada vez que quieras hacer referencia al kernel en el momento de compilar el módulo, basta con usar dicho enlace.

“Hola, kernel!”

Bien, es hora de crear nuestro primer módulo. Sin más rodeos, el código sería el siguiente:

/* El nombre del archivo es 'hola.c'. */
#include <linux/module.h>      // para todos los modulos
#include <linux/init.h>        // para las macros entry/exit
#include <linux/kernel.h>      // para usar la macro printk
#include <asm/current.h>       // informacion del proceso (solo por diversion)
#include <linux/sched.h>       // para usar la estructura "task_struct"
static int hola(void)
{
     printk(KERN_INFO "Hola, el modulo esta siendo cargado.\n");
     printk(KERN_INFO "El user space del proceso es '%s'\n", current->comm);
     printk(KERN_INFO "El PID es  %i\n", current->pid);
     return 0;       // para indicar que todo ha salido bien
}
static void adios(void)
{
     printk(KERN_INFO "Chao, el modulo esta siendo removido.\n");
}
module_init(hola);     // lo que se debe llamar al cargar un modulo
module_exit(adios);    // lo que se debe llamar al remover un modulo

MODULE_AUTHOR("Robert P. J. Day");
MODULE_AUTHOR("Cristian Castiblanco [solo lo puse en castellano]");
MODULE_LICENSE("Dual BSD/GPL");
MODULE_DESCRIPTION("Aqui puedes poner una descripcion de tu modulo");

Algunas observaciones acerca del código de arriba:

• Técnicamente, no es necesario imprimir cosas cada vez que se carga o remueve un módulo (con printk). Pero puesto que es nuestro primer módulo, y aún no hace nada especial, es más divertido si lo dejamos así.
• Es necesario hacer que la función de inicio retorne 0, si queremos indicar que la carga fue satisfactoria.
• No, no es necesario poner una coma después de indicar el nivel de logs (KERN_INFO). Es un error común hacerlo.

Eso es todo… ¡vamos a compilarlo!

El archivo Makefile

Este es el archivo Makefile que necesitaremos:

ifeq ($(KERNELRELEASE),)  

KERNELDIR ?= /lib/modules/$(shell uname -r)/build
PWD := $(shell pwd)  

.PHONY: build clean

build:
	$(MAKE) -C $(KERNELDIR) M=$(PWD) modules  

clean:
	rm -rf *.o *~ core .depend .*.cmd *.ko *.mod.c
else  

$(info Building with KERNELRELEASE = ${KERNELRELEASE})
obj-m :=    hola.o

endif

Como has de saber, los archivos Makefile indican las reglas necesarias para compilar código. En este caso, explicándolo a groso modo, lo que hace el Makefile es detectar que aún nos encontramos en el directorio de desarrollo de nuestro módulo, y por lo tanto se dirige al directorio del kernel, compila el módulo desde ahí y se devuelve. Para probarlo basta con ejecutar el comando make:

Examinar el módulo

Una vez compiles el módulo obtendrás un archivo con extensión .ko. Si quieres echarle un ojo a dicho archivo, puedes usar el comando modinfo así:

$ sudo modinfo hola.ko
filename:       hola.ko
description:    Aqui puedes poner una descripcion de tu modulo
license:        Dual BSD/GPL
author:         Cristian Castiblanco [solo lo puse en castellano ]
author:         Robert P. J. Day
depends:
vermagic:       2.6.29-gentoo-r5 SMP mod_unload CORE2

En Gentoo es necesario ejecutarlo con privilegios; en otras distros puedes ejecutarlo normalmente.

Cargar o remover el módulo

Llego la hora de cargar nuestro módulo. Para ello, como comenté anteriormente, es necesario poseer privilegios administrativos. Al grano:

¿Y donde está lo que imprimimos con printk? Bien, no es común imprimir en consola cosas mientras un módulo es cargado o removido; en este caso, la salida va a dar al archivo de logs principal de Linux (/var/log/messages); puedes ver la salida con el comando dmesg o directamente en dicho archivo:

Conclusión

Estas son apenas las bases que deberíamos tener para comenzar con la construcción de un módulo para el kernel de Linux. Es de valiosa ayuda jugar un poco con este ejemplo, de tal manera que podamos estar seguros que todo irá bien cuando hagamos algo un poco más complejo.

Descargar código fuente del ejemplo

Continuando con la experiencia en PC-BSD, veremos cómo configurar la red. Los pasos son similares a como se haría en Linux, aun así, puesto que algún par de cosas cambian, he preferido dejarlo documentado.

Lo primero que deberíamos hacer es identificar el nombre que el sistema le ha dado a nuestras tarjetas, en mi caso la tarjeta es le0 (que es el equivalente al típico eth0 en Linux). Para hacerlo basta con ejecutar desde una consola el comando ifconfig.

Configuración manual de la red

Para configurar manualmente nuestra red podemos ejecutar los siguientes comandos:

Explicación

• En el primero comando usamos ifconfig para configurar la interfaz de red le0, con la dirección IP 192.168.16.8 y la máscara de red 255.255.255.0. La opción up activa la interfaz de red.
• Posteriormente usamos el comando route para añadir el gateway por defecto de la red.
• El comando netstat -r nos permite verificar que el gateway fue añadido correctamente. Interesante tener en cuenta que, a diferencia de Linux, para mirar las tablas de enrutamiento no se usa route -n sino netstat -r

Configurar la interfaz de red con DHCP

Esta es la opción más sencilla y la que recomiendo. Si tienes un servidor DHCP en la red, lo mejor será configurar nuestra interfaz de red para que solicite una IP automáticamente. Para ello basta con abrir el archivo /etc/rc.conf y modificar nuestra interfaz de red de tal manera que quede así:

Además, si estás usando otro cliente DHCP diferente del que trae por defecto el sistema, o quieres ejecutarlo con alguna opción en especial, debes modificar estas variables: