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

¡Hola a todos! Hace un par de días perdí la partición donde tenía mi /home. Afortunadamente pude recuperar el 98% de los archivos que necesitaba. Es decir, en realidad no me interesaba recuperar imágenes, música, etc… lo único importante era recuperar los archivos PHP con los que había estado trabajando.

Aclaro esto puesto que esta entrada se va a enfocar en la configuración manual de Foremost, un programa para hacer carving, de tal manera que rescatemos solamente aquello que realmente nos interesa. Existen otros programas, pero este fue el que realmente me ayudó en esos momentos de pánico.

¿Cómo funciona? Foremost trabaja con imágenes generadas con dd o particiones directamente, y se basa en el análisis de encabezados y footers de los archivos para ‘extraer’ lo que se pueda salvar.

Dicho esto, tienes dos opciones:

• Si tienes otra partición con suficiente espacio para almacenar un backup de la partición a ser tratada, puedes usar el comando dd y luego trabajar sobre esa imagen. En esta entrada se explica con más detalle cómo hacer esto.
• Si no tienes espacio (tal como me ocurrió a mi), puedes trabajar directamente sobre la partición (i.e. el archivo /dev/sdaX ó /dev/hdbX, etc.). Solo ten en mente que NO deberías montar dicha partición, al menos no en modo de lectura-escritura.

Instalación de Foremost

La instalación es bastante sencilla ya que Foremost se incluye en prácticamente todos los repositorios de cualquier distribución. Así que puedes usar tu gestor de paquetes preferido. Siendo tan sencilla la instalación por repositorios, solo me queda mostrar la instalación manual que es incluso más sencilla… descargamos la última versión de Foremost (1.5.6 al momento de escribir esta entrada), descomprimimos, compilamos e instalamos:

Ejemplo básico de uso de Foremost

El siguiente comando de ejemplo es un de los tantos cientos de miles que te encontrarás en la red… no me enfocaré mucho en este aspecto porque ya se encuentra muy bien documentado:

Básicamente le estamos diciendo al Foremost que busque archivos de tipo PDF en el archivo de imagen (creado con dd) imagen.iso y que los guarde en pdfs-recuperados. Lo único que nos interesa recalcar en este punto es que Foremost tiene un set de archivos predefinidos de los cuales conoce su header y footer (como los PDFs en este caso); este set se compone de los archivos más comunes (imágenes  y videos en diferentes formatos, archivos de office, zips, etc.) Pero… ¿qué pasa con otro tipo de archivos menos comunes? Tranquilo, ya vamos para allá

Ejemplo de configuración del Foremost

Foremost puede ser configurado mediante un archivo (por defecto: /etc/foremost.conf) de tal manera que no tengamos que especificar el tipo de archivo a buscar y, lo que es mejor, podemos definir nuestros propios tipos de archivos. En nuestro ejemplo, te meterás en mis zapatos, te imaginarás que has perdido el trabajo de tres días y que tu objetivo es rescatar unos cuantos archivos de PHP.

Entonces… ¿por donde comenzar? Bien… lo primero es echar un vistazo al archivo /etc/foremost.conf en donde puedes encontrar patrones de búsqueda para diferentes tipos de archivo (de hecho, son las que usa Foremost cuando usamos el flag -t). La sintáxis de estos patrones es sencilla y consta de una sola línea; esta línea tiene los siguientes parámetros separados por espacios o tabulaciones:

• Extensión del archivo… ¿debo explicar esto?
• Definir si se debe hacer distinción entre mayúsculas y minúsculas al buscar el header y footer del archivo. Pon ‘y’ si deseas que sea case-sensitive o ‘n’ en caso contrario.
• Tamaño máximo del archivo.
• Encabezado: lo que se debe buscar en los encabezados de los archivos; puede ser especificado en texto plano o, mejor aún, en hexadecimal.
• Footer (opcional): lo que se debe buscar al final de los archivos; puede ser especificado en texto plano o, mejor aún, en hexadecimal.

Por ejemplo, este es uno de los que se encuentra configurados por defecto en el Foremost:

jpg y 20000000 \xff\xd8\xff\xe1 \xff\xd9

Básicamente busca archivos con extensión .jpg y con un tamaño máximo de 20000000 bytes. Además especifica uno de los posibles encabezados que un archivo tipo JPEG puede tener (\xff\xd8\xff\xe1) y su footer (\xff\xd9).

Como puedes ver, el encabezado y el footer pueden ser especificados en hexadecimal. Esto es bastante útil ya que en muchos casos no necesitamos simples archivos de texto sino que podríamos querer recuperar uno binario. En cualquier caso, es recomendable usar hexadecimal… pero ¿cómo se qué debo poner? Bien… recuerda que tu misión es recuperar los archivos PHP, así que… ¿qué tal si creamos uno para ver cómo se ve en hexadecimal?

Creamos entonces un archivo con el siguiente contenido y lo guardamos como test.php:

<?php
if($meLoTire){
	echo "o_O mode-panic:on";
}
?>

Ahora debemos abrir este archivo con algún editor hexadecimal. Si usas Gnome, Ghex es una buena opción (sino, también)… lo instalas desde los repositorios y con él abres el archivo que acabas de crear… este lucirá así:

¡Ahora ya podemos configurar Foremost como expertos, puesto que ya sabemos qué hexadecimales poner! Cada caracter del archivo que creamos equivale a un valor en hexadecimal y nos interesa enfocarnos en la representación hexadecimal de “<?php” puesto que así comienzan los archivos en los que estamos interesados.

Así que para este caso, los hexadecimales son 3C, 3F, 70, 68 y 70. Por lo tanto podemos crear un nuevo patrón dentro de /etc/foremost.conf que luzca algo así:

php y 100000 \x3C\x3F\x70\x68\x70

Si queremos ser más precisos podemos especificar el footer:

php y 100000 \x3c\x3f\x70\x68\x70 \7d\0a\3f\x3e

Fíjate que he definido un footer bastante concreto que hará que Foremost busque archivos que finalicen con un ‘}’ seguido de un ‘Enter’ (retorno de carro) y finalmente con “?>”. Una vez hayamos terminado de configurar los patrones con los que queramos iniciar la búsqueda, guardamos y cerramos el archivo.

Puesto que es el archivo por defecto no es necesario especificarlo al momento de ejecutar Foremost. Esto por supuesto implica que puedes crear un archivo con patrones en cualquier otro lado, y en tales casos debes referencialo con el flag -c. ¡Que comience el carving!

Como puedes ver, no especificamos ningún tipo  de archivo así que Foremost se enfocará en aquellos configurados en el archivo .conf. Además, en este caso estamos especificando directamente la partición. Esto podría llevar un rato, así que tienes tiempo de leer algo entretenido ¿qué tal esta bonita guía sobre Vi? ¿o esta otra sobre un hermoso Gentoo/BSD?

Una vez Foremost haya terminado su trabajo… el tuyo apenas comienza. Aunque Foremost es un excelente programa, los resultados no pueden ser 100% confiables (¿hay algo que lo sea?). Y para empeorar las cosas, Foremost NO recupera los nombres de los archivos. En vez de ello, crea una secuencia de archivos numéricos con la extensión; cosas como 8392383874.php ó 239492782.php ¿chévere, no?

Todo parece que pasaremos un buen rato jugando con nuestro querido amigo GREP; y es que este maravilloso comando puede ser realmente útil en estos casos. Así que aquí van algunos comandos que te podrían servir:

• grep busqueda changos.ext
  Busca la cadena ‘busqueda’ dentro del archivo changos.ext
• ¿qué tal una búsqueda en todos los archivos? Esto podría servir para nuestro caso de los PHP:
  cat *.php | grep -l cosa_a_buscar
• ¿y si queremos buscar un string en varios archivos que se encuentran en diferentes directorios? Este comando es de los que más uso a diario:
  find /ruta/ -exec grep -l cosa_a_buscar {} \;

Cosas por considerar

• Existe una gran probabilidad que los datos recuperados no estén del todo bien formados. Por ejemplo, podrían tener “basura” dentro. Esto es posible de corregir en archivos de texto, ya que solo necesitas un editor decente y un par de minutos para “ver qué te sirve”.
• Si los archivos recuperados tienen basura dentro, es mejor usar editores de texto en consola que no se quejan tanto al momento de editarlos. Gedit simplemente no los abre.
• Algunas veces los archivos quedan fragmentados; esto es, en un archivo recuperado queda una parte de lo que buscas, y en otro queda el restante. Por esto, es bastante útil que uses herramientas como Meld (excelente por cierto).  Considera este ejemplo de la vida real: en el archivo blablaa.php tenía parte inicial del archivo mientras que en blebelbel.php tenía el resto:

Esto es difícil de notar ‘a ojo’, por lo que puedo decir que Meld me salvó el trasero una vez más (y de paso se ganó una donación). Así, combinando el trabajo de Foremost y la ayuda de Meld pude recuperar prácticamente todo lo que necesitaba.

Pero, te repito, si fuesen archivos binarios los que quieres rescatar la cosa sería mucho más difícil. En este caso, ‘la basura’ se puede identificar fácilmente dentro del archivo, y de la misma manera se puede eliminar. En una archivo binario sin embargo es un poco más difícil.

Otros buenos programas con propósitos similares

• TestDisk (aka, PhotoRec)
• Scalpel
• Magic Rescue
• Sleuth Kit y Autopsy
• Sleuthkit

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

En esta guía aprenderemos a obtener información de los recursos sistema en Java, usando la librería Sigar. Los datos que podremos extraer son los siguientes:

• Información de la CPU.
• Espacio en disco disponible.
• Cantidad de espacio que consume un directorio en específico.
• Cantidad de memoria RAM disponible y en uso.
• Información de red (dirección IP, nombre de la NIC, puertos abiertos, tablas de enrutamiento, etc.)
• Información de los procesos que se están ejecutando en el sistema.
• Asignación de variables de entorno.
• Uptime, o cantidad de tiempo que el equipo ha estado encendido.
• Nombre y versión del sistema operativo.
• Usuarios logueados actualmente.

Resaltadas en negrita está la información en la que nos concentraremos en el ejemplo. Pero antes aclaremos un poco que es Sigar: el API de Sigar nos proporciona una serie de métodos que nos permiten obtener información del sistema operativo; consta de una librería de Java (.jar) y otras librerías nativas específicas para cada sistema operativo soportado (libsigar-amd64-linux.so, para Linux de 64 bits o sigar-x86-winnt.dll para Windows de 32 bits, por poner un ejemplo).

Teniendo esto en cuenta, para hacer funcionar dicha API en una de nuestras aplicaciones, bastaría con tener el archivo .jar y la librería específica de nuestro sistema operativo. En el desarrollo del ejemplo se usará Eclipse y, aunque se explicará cómo añadir las librerías en el proyecto, se da por conocido el funcionamiento del flag --classpath de los comandos javac y java (obligatorio si no se usa ningún IDE).

El resultado…

Siempre pongo primero el resultado ya que nos aclara la visión de hacia donde vamos, y de paso saber si lo que está aquí es lo que buscamos. Esta es la salida del programa en mi Gentoo Linux:

====Informacion del sistema====
Descripcion del SO	Gentoo 2.1.6
Nombre del SO		Linux
Arquitectura del SO	x86_64
Version del SO		2.6.31-gentoo
Nivel de parches	unknown
Fabricante		Gentoo
Version SO		2.1.6
Encendido durante:	6:15

==== Informacion de la CPU ====
Fabricante:		Intel
Modelo			Core(TM)2 Duo CPU     T5750  @ 2.00GHz
Mhz			1994
Total CPUs		2
CPUs fisiscas		1
Nucleos por CPU		2
Tamanio cache		2048

Consumo de CPU 0	22.0%
Consumo de CPU 1	2.0%
Consumo total de CPU	6.0%

====Informacion del sistema de archivos====

dispos.|total|usado|disponible|%uso|dir|tipo

/dev/root|24042944|10698228|12123376|47%|/|ext4
/dev/sda1|175457764|155825380|10719932|94%|/home|ext3

====Informacion de la memoria====
Cantidad de memoria RAM: 3968MB
Total: 4056984
Usada: 2307076
Disponible: 1749908
Memoria SWAP total: 1052248
Memoria SWAP usada: 0
Memoria SWAP libre: 1052248

Descargar Sigar

Puedes descargar Sigar de la página oficial: http://support.hyperic.com/display/SIGAR/Home que incluye además ejemplos para Java, Perl, C, Python, Ruby, y más. Puedes además descargar el código fuente que se encuentra licenciado bajo la GPL2.

Creación del proyecto en Eclipse

Voy a usar este ejemplo para además enseñar a manipular librerías externas en Eclipse; si lo que te interesa es conocer el código, puedes saltarte a dicha sección directamente.

Creamos un proyecto en Eclipse llamado InfoSistema:

Ahora creamos una carpeta dentro del proyecto llamada lib, en donde guardaremos las librerías de Sigar (.jar, .so, .dll, etc.):

Ahora descomprimimos el archivo que descargamos de Sigar, y copiamos los archivos que se encuentran en la carpeta sigar-bin/lib a la carpeta lib de nuestro proyecto. En mi caso la copia la hice con este comando:

Cabe resaltar que bastaría con copiar el archivo llamado sigar.jar y la librería del sistema donde vamos a correr nuestro programa (libsigar-amd64-linux.so en mi caso).

Una vez hecha la copia, hacemos clic en la raiz del proyecto en Eclipse y presionamos F5 para actualizar el árbol de ficheros; de esta manera Eclipse sabrá de los nuevos archivos que hemos copiado. Y lo que haremos a continuación será enlazar la librería sigar.jar a nuestro proyecto, para lo cual hacemos clic derecho en el mismo, Build Path -> Configure Build Path…

En la ventana que aparece, seleccionaremos la pestaña Libraries y hacemos clic en el botón Add JARs… Seleccionamos el archivo sigar.jar y hacemos clic en OK:

Ahora que la librería se encuentra añadida, podemos utilizar el API que Sigar nos ofrece. ¡Pasemos entonces al código!

Información del sistema…

La siguiente clase nos permite obtener información del sistema operativo, como el nombre, la versión, la arquitectura, etc. Creamos una nueva clase llamada InfoSO con el siguiente código:

import org.hyperic.sigar.OperatingSystem;
import org.hyperic.sigar.Sigar;
import org.hyperic.sigar.SigarException;

public class InfoSO {
	private Sigar sigar = new Sigar();
	public void imprimirInfo() {
		OperatingSystem sys = OperatingSystem.getInstance();
		System.out.println("Descripcion del SO\t" + sys.getDescription());
		System.out.println("Nombre del SO\t\t" + sys.getName());
		System.out.println("Arquitectura del SO\t" + sys.getArch());
		System.out.println("Version del SO\t\t" + sys.getVersion());
		System.out.println("Nivel de parches\t" + sys.getPatchLevel());
		System.out.println("Fabricante\t\t" + sys.getVendor());
		System.out.println("Version SO\t\t" + sys.getVendorVersion());
		try {
			imprimirUptime();
		} catch (SigarException e) {
			e.printStackTrace();
		}
	}
	public void imprimirUptime() throws SigarException {
		double uptime = sigar.getUptime().getUptime();
		String resultado = "";
		int dias = (int) uptime / (60 * 60 * 24);
		int minutos, horas;
		if (dias != 0)
			resultado += dias + " " + ((dias > 1) ? "dias" : "dia") + ", ";
		minutos = (int) uptime / 60;
		horas = minutos / 60;
		horas %= 24;
		minutos %= 60;
		if (horas != 0)
			resultado += horas + ":" + (minutos < 10 ? "0" + minutos : minutos);
		else
			resultado += minutos + " min";
		System.out.println("Encendido durante:\t" + resultado);
	}
}

Aspectos importantes:

• La clase que nos proporciona los métodos para recuperar información del sistema operativo es OperatingSystem.
• Con los métodos getName y getDescription obtenemos el nombre del sistema operativo y descripción (por ejemplo: nombre = Linux; descripción = Gentoo 2.1.6).
• El método getUptime de la clase Sigar nos permite conocer cuanto tiempo ha estado prendido el equipo analizado.

Información de la CPU…

La siguiente clase nos permitirá conocer el modelo del procesador, sus capacidades, la cantidad de núcleos y el uso de los mismos, etc. Creamos una nueva clase llamada InfoCPU con el siguiente código:

import org.hyperic.sigar.CpuInfo;
import org.hyperic.sigar.CpuPerc;
import org.hyperic.sigar.Sigar;
import org.hyperic.sigar.SigarException;

public class InfoCPU {
	private Sigar sigar;

	public void imprimirInfoCPU() {
		sigar = new Sigar();
		CpuInfo[] infos = null;
		CpuPerc[] cpus = null;
		try {
			infos = sigar.getCpuInfoList();
			cpus = sigar.getCpuPercList();
		} catch (SigarException e) {
			e.printStackTrace();
		}

		CpuInfo info = infos[0];
		long tamanioCache = info.getCacheSize();
		System.out.println("Fabricante:\t\t" + info.getVendor());
		System.out.println("Modelo\t\t\t" + info.getModel());
		System.out.println("Mhz\t\t\t" + info.getMhz());
		System.out.println("Total CPUs\t\t" + info.getTotalCores());
		if ((info.getTotalCores() != info.getTotalSockets())
				|| (info.getCoresPerSocket() > info.getTotalCores())) {
			System.out.println("CPUs fisiscas\t\t" + info.getTotalSockets());
			System.out
					.println("Nucleos por CPU\t\t" + info.getCoresPerSocket());
		}

		if (tamanioCache != Sigar.FIELD_NOTIMPL)
			System.out.println("Tamanio cache\t\t" + tamanioCache);
		System.out.println("");

		for (int i = 0; i < cpus.length; i++)
			System.out.println("Consumo de CPU " + i + "\t"
					+ CpuPerc.format(cpus[i].getUser()));

		try {
			System.out.println("Consumo total de CPU\t"
					+ CpuPerc.format(sigar.getCpuPerc().getUser()));
		} catch (SigarException e) {
			e.printStackTrace();
		}
	}
}

Aspectos importantes:

• Se deben usar objetos de CpuInfo y CpuPerc que proporcionan los métodos para recuperar información del procesador. Dichos objetos se crean a partir de un objeto principal de tipo Sigar.
• Para extraer información acerca del procesador usamos los métodos de la clase CpuInfo (por ejemplo getVendor o getModel).
• Los datos específicos de cada núcleo de nuestro procesador se extraen con los métodos de la clase CpuPerc (getUser para obtener el uso de un núcleo, por ejemplo).

Información del sistema de archivos…

La siguiente clase nos permite obtener información del sistema de archivos: unidades montadas, espacio en disco, tipo de sistema de archivos, etc. Creamos una nueva clase llamada InfoSistemaArchivos con el siguiente código:

import org.hyperic.sigar.Sigar;
import org.hyperic.sigar.SigarException;
import org.hyperic.sigar.FileSystem;
import org.hyperic.sigar.FileSystemUsage;
import org.hyperic.sigar.NfsFileSystem;
import org.hyperic.sigar.SigarProxy;
import org.hyperic.sigar.SigarProxyCache;

public class InfoSistemaArchivos {
	private SigarProxy proxy;
	private Sigar sigar;

	public InfoSistemaArchivos() {
		sigar = new Sigar();
		proxy = SigarProxyCache.newInstance(sigar);
	}

	public void imprimirInfo() throws SigarException {
		FileSystem[] listaSistemaArchivos = proxy.getFileSystemList();
		System.out.println("\ndispos.|total|usado|disponible|%uso|dir|tipo\n");
		for (int i = 0; i < listaSistemaArchivos.length; i++)
			imprimirSistemaArchivos(listaSistemaArchivos[i]);
	}

	public void imprimirSistemaArchivos(FileSystem sistemaArchivos)
			throws SigarException {
		long usado, disponible, total, porcentaje;

		try {
			FileSystemUsage uso;
			if (sistemaArchivos instanceof NfsFileSystem) {
				NfsFileSystem nfs = (NfsFileSystem) sistemaArchivos;
				if (!nfs.ping()) {
					System.out.println(nfs.getUnreachableMessage());
					return;
				}
			}
			uso = sigar.getFileSystemUsage(sistemaArchivos.getDirName());

			usado = uso.getTotal() - uso.getFree();
			disponible = uso.getAvail();
			total = uso.getTotal();

			porcentaje = (long) (uso.getUsePercent() * 100);
		} catch (SigarException e) {
			// por ejemplo, si en al procesar D:\ en windows falla
			// con "Device not ready"
			usado = disponible = total = porcentaje = 0;
		}

		String porcentajeUso;
		if (porcentaje == 0)
			porcentajeUso = "-";
		else
			porcentajeUso = porcentaje + "%";

		System.out.print(sistemaArchivos.getDevName());
		System.out.print("|" + total);
		System.out.print("|" + usado);
		System.out.print("|" + disponible);
		System.out.print("|" + porcentajeUso);
		System.out.print("|" + sistemaArchivos.getDirName());
		System.out.println("|" + sistemaArchivos.getSysTypeName());
	}
}

Aspectos importantes:

• La clase que nos proporciona los métodos para obtener información de una unidad en específico es FileSystem.
• El método getDevName nos devuelve el nombre del dispositivo referenciado por el objeto de la clase FileSystem.
• Los métodos getTotal y getAvail devuelven un long que representa el espacio total del dispositivo y espacio disponible, respectivamente.
• Para conocer el tipo de sistema de archivos (ext4, ntfs, fat, btrfs, etc.) utilizamos el método getSysTypeName.

Información de la memoria…

La siguiente clase nos permite conocer la cantidad de memoria RAM que tiene el equipo, así como la que se está usando actualmente (tanto memoria física como virtual, aka, swap). Creamos una nueva clase llamada InfoMemoria con el siguiente código:

import org.hyperic.sigar.Mem;
import org.hyperic.sigar.Sigar;
import org.hyperic.sigar.Swap;
import org.hyperic.sigar.SigarException;

public class InfoMemoria {
	private Sigar sigar = new Sigar();
	public void imprimirInfo() throws SigarException {
		Mem memoria = sigar.getMem();
		Swap intercambio = sigar.getSwap();

		System.out.println("Cantidad de memoria RAM: "+ memoria.getRam() + "MB");

		System.out.println("Total: "+enBytes(memoria.getTotal()));
		System.out.println("Usada: "+enBytes(memoria.getUsed()));
		System.out.println("Disponible: "+enBytes(memoria.getFree()));

		System.out.println("Memoria SWAP total: "+enBytes(intercambio.getTotal()));
		System.out.println("Memoria SWAP usada: "+enBytes(intercambio.getUsed()));
		System.out.println("Memoria SWAP libre: "+enBytes(intercambio.getFree()));

	}
	private Long enBytes(long valor) {
		return new Long(valor / 1024);
	}
}

Aspectos importantes:

• La clase Mem nos proporciona métodos para obtener información de la memoria del sistema.
• La clase Swap hace lo mismo que Mem, pero para la memoria virtual.
• Los métodos getTotal y getUsed nos devuelven un long que representa (en bits) la cantidad de memoria del equipo y lo que está usando, respectivamente.

La clase main…

El main de nuestro proyecto estará contenido en la clase InfoSistema:

import org.hyperic.sigar.SigarException;
public class InfoSistema {
	public static void main(String[] args) {
		try {
			System.out.println("====Informacion del sistema====");
			new InfoSO().imprimirInfo();
			System.out.println("\n==== Informacion de la CPU ====");
			new InfoCPU().imprimirInfoCPU();
			System.out.println("\n====Informacion del sistema de archivos====");
			new InfoSistemaArchivos().imprimirInfo();
			System.out.println("\n====Informacion de la memoria====");
			new InfoMemoria().imprimirInfo();
		} catch (SigarException e) {
			e.printStackTrace();
		}
	}
}

Eso es todo, solo nos queda ejecutar el proyecto y, opcionalmente, crear un archivo .jar para ejecutar en cualquier lado.

Descargas…

• Descarga del código fuente usado en esta entrada
• Descargar librerías de Sigar de SourceForge

Contribuyendo a la excelente labor de mi amigo Cortex, vamos con este pequeño artículo.

Una de las tareas más dispendiosas a la hora de configurar el kernel es determinar qué opción/driver activar para determinado dispositivo. La idea de este artículo es dar a conocer una excelente herramienta online que nos permitirá conocer mejor nuestro sistema, y de paso saber los nombres de los drivers que podemos usar por cada dispositivo.

La página en cuestión es http://kmuto.jp/debian/hcl/ y contiene una base de datos de IDs de dispositivos PCI, que nos permite consultar información acerca de nuestros dispositivos y los drivers que los controlan.

Uso

Para usarlo debemos ejecutar el siguiente comando:

y copiamos la salida en el area de texto que aparece al entrar a http://kmuto.jp/debian/hcl/; hacemos clic en el botón Comprobar y obtendremos un listado de dispositivos vs. nombre del driver.

Por ejemplo, mi laptop tiene una ranura para insertar memorias SD; el nombre de dicho dispositivo es R5C822 SD/SDIO/MMC/MS/MSPro Host Adapter y el driver es sdhci-pci.

Con dicha información, podemos hacer una búsqueda (presionando la tecla /) en la configuración del kernel (cuando hacemos un make menuconfig):

El resultado es la ubicación exacta de la opción que debes habilitar para tener tu dispositivo funcionando:

Eso es todo. Ahora podemos estar seguros de escoger el driver adecuado y podemos compilar nuestro kernel normalmente.

Anterior artículo…

Continuando con la serie de posts dedicados al Kernel, hoy vamos a hablar sobre las cámaras web y la herramienta sysctl.

Cámaras Web

En la actualidad, el kernel tiene muy buen soporte para las cámaras web, tanto las integradas como las externas. Basado en mi experiencia, nunca he tenido ningún problema con dispositivos de captura de video en Linux aunque me imaginó que en algún hardware habrá incompatibilidades. La ventaja es que los desarrolladores del kernel cada día trabajan por mejorarlo y desarrollando controladores para maximizar el soporte en la mayor cantidad de máquinas posibles.

Lo primero que debemos hacer es identificar la referencia del dispositivo. Si tienes un portatil y lo que buscas es hacer funcionar la cámara integrada que trae, usando el driver UVC sería suficiente:

Device Drivers  --->
     <*> Multimedia support  --->
          [*]   Video capture adapters  --->
               [*]   Autoselect pertinent encoders/decoders and other helper chips
               [*]   V4L USB devices  --->
                    <*>   USB Video Class (UVC)
                          [*]     UVC input events device support

Ahora, en caso de que la cámara sea externa debes conectarla y hacer un lsusb. Hay tantos modelos disponibles que sería difícil hacer una guía definitiva, además de que ya existe un completo HOWTO que explica esto. Lo que haré, será mostrar un ejemplo haciendo uso de una vieja cámara Genius que tengo. Si la conecto y hago un dmesg puedo ver la información del dispositivo:

Ahora lsusb:

Teniendo el ID, debemos buscar cuál es el módulo necesario para esta cámara. Aquí tienes una larga lista de IDs con su respectivo módulo. Si buscamos también en la base de datos de drivers del kernel veremos la configuración que debemos hacer y el módulo a activar. El driver en cuestión es: gspca_pac207.

<*>   GSPCA based webcams  --->
     <M>   Pixart PAC207 USB Camera Driver

Si compilaste como módulo no olvides agregarlo al inicio del sistema (si es lo que deseas). En Gentoo con OpenRC y Baselayout 2:

Para esta cámara es necesario tener instalada la librería v4l (Video 4 Linux).

Y listo. Reiniciamos con el nuevo kernel y usamos cualquier programa como cheese para comprobar que todo funciona bien.

Sysctl

A raíz de un comentario de arpunk, he decidido posponer uno de los temas que iba a tocar en este artículo y hablar sobre sysctl.

El kernel Linux es tan flexible que te permite modificar la manera en que trabaja, dinámicamente, a través del comando sysctl. Sysctl provee de una interfaz que permite examinar y cambiar cientos de parámetros en núcleos Linux y BSD. Gracias a esta herramienta podemos modificar y optimizar el kernel sin tener que recompilarlo. Los cambios son realizados inmediatamente e incluso pueden ser definidos como persistentes, de manera que continúen después de reiniciar.

Para ver los parámetros actuales del kernel en ejecución:

Con el segundo lo que hacemos es ver el valor de un determinado parámetro, en este caso vm.swappiness. Suponiendo que quisiéramos decirle al kernel que use más la memoria RAM que la swap ó habilitar el forwarding en IPv4, bastaría con cambiar el valor de estas variables:

Recuerda que las modificaciones que hagas con este comando serán temporales, y la próxima vez que reinicies el sistema se cargarán los valores por defecto. Para cambiar este comportamiento, hay que editar el archivo /etc/sysctl.conf

Básicamente eso es sysctl. El tema podría tornarse más extenso pero la idea de estos artículos, es tan sólo, recopilar conceptos en torno al kernel Linux. Para más información man sysctl.

Hasta aquí por hoy. En el próximo artículo hablaremos un poco de optimizaciones para el procesador y de otras buenas prácticas a la hora de compilar el núcleo.

Hola a todos! Otra vez yo, Cortex, que hace un buen rato no me pasaba por aquí.

Hoy me gustaría hablar sobre un tema en el que seguro todos tenemos muchas lagunas, configurar el kernel. Si alguna vez has instalado ó intentando instalar Gentoo te habrás dado cuenta que en el ritual de instalación debes de compilar tu propio núcleo, incluyendo también la configuración del mismo. Desde mi experiencia, este suele ser un punto en el que la mayoría de usuarios se quedan; es cierto que también existe genkernel, una herramienta que facilita por completo este proceso pero que también, entre otras cosas, ralentiza mucho el arranque.

Casi la totalidad de distribuciones Linux, incluyen en su sistema un kernel con soporte para la mayor cantidad de hardware posible y en el booteo hay un script que se encarga de identificar el perfil del equipo en cuestión y cargar los módulos respectivos (sonido, disco, sistemas de archivos, etc.). Este sistema me parece excelente, puesto que sobretodo al usuario nuevo le ahorra mucho trabajo a la hora de poner a funcionar su distribución, pero como dije anteriormente no es lo más óptimo, sobretodo si queremos el mejor rendimiento posible.

No pretendo con esta entrada crear una guía completa de configuración del kernel. Primero, porque mis conocimientos en este tema son limitados, o sino que lo diga Javi, que siempre le toca aguantarse mis quejas porque no me funcionan bien las cosas Y segundo, porque todos tenemos necesidades diferentes y puede que algunos necesiten soporte para determinadas cosas que otros no. Lo que sí me gustaría es hablar sobre buenas prácticas a la hora de trabajar con el núcleo y sobre problemas muy comunes que surgen cuando hacemos una configuración desde 0, como dispositivos que no funcionan, entre otras cosas. El post está abierto a cualquier aporte/mejora/correción que quieran hacer.

Brillo en pantallas LCD

Son varias las personas que alguna vez me han preguntado como pueden hacer funcionar las teclas para definir la intensidad del brillo de la pantalla. Si usas portatil, habrás notado que es una funcionalidad demasiado útil y que además es muy maluco tener que trabajar únicamente con el brillo que el laptop haya decidido definir al ser encendido.

• Lo primer es activar el controlador:

Device Drivers  --->
     Graphics Support --->
          [*] Lowlevel video output switch controls
          [*] Backlight & LCD device support  --->
               <*>   Lowlevel LCD controls
               <*>     Platform LCD controls
               -*-   Lowlevel Backlight controls
               <*>     Generic (aka Sharp Corgi) Backlight Drive
      Display device support  --->
           <*> Display panel/monitor support

• Ahora nos dirigimos a las opciones de ACPI y activamos el manejo de video:

Power management and ACPI options  --->
     [*] ACPI (Advanced Configuration and Power Interface) Support  --->
          <*>   Video

Y con esto bastaría recompilar para disfrutar del brillo

/proc/config.gz

Una opción que quizás muchos no conocen es la de poder acceder a la configuración del kernel en ejecución a través del archivo /proc/config.gz. Actívemosla y curémosnos en salud ante la pérdida del preciado .config.

General setup  --->
     <*> Kernel .config support
     [*]   Enable access to .config through /proc/config.gz

Para disponer del archivo de configuración:

Sonido como módulo

Entre los problemas más comunes en Linux está el sonido. Sobretodo si trabajamos con versiones de ALSA muy viejas ya que nos toca recurir a hacks ó pasar parámetros a la hora de cargar los módulos. Por si no está claro para alguien, ALSA (Advanced Linux Sound Architecture) a grosso modo, es el encargado de la gestión del sonido en Linux, reemplazando al obsoleto OSS. No es la única opción, pero sí la mejor en la mayoría de los casos.

Existen 3 formas de instalar ALSA:

• Desde los drivers del kernel (estáticamente)
• Desde los drivers del kernel (módulo)
• Drivers externos (alsa-drivers)

La más recomendada es la segunda. Las ventaja de compilar el sonido como módulo es que no tenemos que preocuparnos de identificar cual es el controlador apropiado para nuestra tarjeta, sino, simplemente dejar hacer su trabajo a alsaconf y usar alsamixer para definir el volumen. Aparte de que también se obtiene un mejor rendimiento.

Si quieres profundizar un poco en el tema puedes leer este artículo.

No pondré aquí las opciones que se necesitan activar en el núcleo, puesto que en la documentación de Gentoo está todo perfectamente explicado. Más bien hablemos sobre los micrófonos integrados, esos que a veces resulta tan difícil hacer funcionar.

Abrimos en una shell alsamixer y presionando la tecla Tabulador nos movemos a los dispositivos de Captura. Debemos cambiar en Input Source, Mic por Front Mic y también verificar que los dispositivos Capture y Digital no están mudos y además que tengan el volumen al 100%.

Guardamos la configuración

Ahora abrimos cualquier aplicación para captura de audio y probamos con los dispositivos disponibles a ver cual funciona. Eso es todo.

No quiero alargar más el post, de momento es suficiente. Más adelante veremos como podemos hacer funcionar las cámaras web en Linux y algunas otras cosas.

Cualquier comentario será bien recibido, ¡Hasta pronto!

Siempre olvido cómo generar salida coloreada en la consola, y por lo tanto pierdo tiempo buscando en Internet. Así que, aprovechando que tengo fresco dicho tema, mejor dejo un listado y las instrucciones con el ánimo de que sea útil para alguien (y para mi, por supuesto).

• Negro 0;30
• Gris oscuro 1;30
• Azul 0;34
• Azul resaltado 1;34
• Verde 0;32
• Verde resaltado 1;32
• Cian 0;36
• Cyan resaltado 1;36
• Rojo 0;31
• Rojo resaltado 1;31
• Púrpura 0;35
• Púrpura resaltado 1;35
• Café 0;33
• Amarillo 1;33
• Gris 0;37
• Blanco 1;37

Ejemplos…

Si lo vas a probar usando el comando echo, debes ejecutarlo con el parámetro -e:

echo -e 'Esto es \e[0;31mrojo\e[0m y esto es \e[1;34mazul resaltado\e[0m'

Resultado: 

echo -e 'Así se escribe \e[1;34mG\e[0m\e[1;31mo\e[0m\e[1;33mo\e[0m\e[1;34mg\e[0m\e[1;32ml\e[0m\e[1;31me\e[0m'

Resultado:

Como puedes observar, se trata de poner lo que quieras colorear entre los caracteres de escape \e[CODIGOm y \e[0m.

En este pequeño tip vamos a aprender a instalar paquetes en Gentoo, que no estén dentro de los repositorio oficial de portage. Lo primero por supuesto es contar con ebuild bien formado; en este caso vamos a trabajar con el ebuild de un programa llamado nautilus-actions  [Los ebuild de Portage deben vivir en algún lugar de nuestro sistema; sin embargo, ponerlos en el mismo directorio en donde Portage los guarda por defecto (/usr/portage), no es una buena idea – estos serán eliminados después de la próxima sincronización. Por lo tanto debemos crear un directorio con la misma estructura; a esos tipos de directorios se les llama overlay.