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

Comprimir y descomprimir usando el formato GZIP

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

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

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

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

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

Comprimir usando el formato Bunzip

Aquí un ejemplo muy básico:

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

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

Comprimir usando el formato ZIP

En este caso se utilizan la clase ZipArchive:

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

Verificar la existencia de las librerías

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

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

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

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

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

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

public class Servicio extends Service{

	private static final String TAG = "EjemploServicioBoot";

	private Timer timer;

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

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

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

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

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

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

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

Descargar código fuente

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

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

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

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

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

Esta 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

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

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.

BigInteger y BigDecimal son clases envoltura de los tipos primitivos int y double, sin embargo tienen ventajas sobre los tipos primitivos. Cuando necesites usar números grandes en Java la mejor opción es usar estas clases, ya que su limite de almacenamiento es el límite de memoria que tenga la máquina virtual de Java.

Además, estas clases proporcionan algunos métodos bastante interesantes, como las operaciones básicas o saber si el número es primo o no. Como siempre vamos con algunos ejemplos de apoyo:

Operaciones básicas con la clase BigInteger

En el siguiente ejemplo se hace uso de los métodos add, substract, multiply y divide para realizar las operaciones básicas de suma, resta, multiplicación y división:

import java.math.BigInteger;
public class PruebaOperacionesBasicas {
    public static void main(String args[]){
        BigInteger entero1 = BigInteger.valueOf(45);
        BigInteger entero2 = BigInteger.valueOf(15);
        //sumar con metodo add()
        String texto = "La suma entre "+entero1+
                " y "+entero2+" es "+entero1.add(entero2);
        //restar con metodo substract()
        texto += "\nLa resta entre "+entero1+
                " y "+entero2+" es "+entero1.subtract(entero2);
        //multiplicar con metodo multiply()
        texto += "\nEl producto de "+entero1+
                " y "+entero2+" es "+entero1.multiply(entero2);
        //dividir con metodo divide()
        texto += "\nLa división de "+entero1+
                " y "+entero2+" entre "+entero1.divide(entero2);
        System.out.println(texto);
    }
}

Números primos en Java

Este es un típico ejercicio que nos plantean en la universidad; se trata de hacer un listado de los primeros X números primos. En este caso BigInteger nos proporciona dos métodos muy interesantes: isProbablePrime y nextProbablePrime. El primero de ellos devuelve true si el número es probablemente primo (recordemos que es complejo saber si un número es o no primo cuando es demasiado grande); el segundo devuelve el próximo posible número primo a partir del valor que contenga el objeto.

La siguiente aplicación usa el método nextProbablePrime para listar los primeros 2000 números primos:

import java.math.BigInteger;
public class PruebaNumerosPrimos {
    public static void main(String args[]){
        //iniciar el entero en cero
        BigInteger entero = BigInteger.ZERO;
        StringBuffer texto = new StringBuffer();
        for(int i = 0; i<2000; i++){
            entero = entero.nextProbablePrime();
            texto.append(entero+"\n");
            entero.add(BigInteger.ONE);
        }
        System.out.println(texto);
    }
}

Otros métodos interesantes

La clase BigInteger proporciona además otros métodos que nos ahorrarán bastante tiempo y líneas de código:

• pow, nos permite elevar un número a la potencia que deseemos.
• comparteTo, nos permite comparar si un BigInteger es mayor, igual o menor que otro.
• min y max, nos permiten saber cuál de los dos BigInteger es menor o mayor.

Como mencioné al principio, también es posible usar la clase BigDecimal que funciona de manera similar pero con números de coma flotante.

Descargar código fuente de ejemplos

En el siguiente ejemplo se muestra cómo realizar búsquedas dentro de un arreglo de manera lineal.

Ejemplo…

using System;
using System.Drawing;
using System.Windows.Forms;
namespace BusquedaLineal
{
   public class BusquedaLineal : Form
   {
      private Button botonBuscar;
      private TextBox cajaEntrada;
      private Label labelSalida;
      int[] a = { 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26,
                  28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50 };
      public BusquedaLineal()
      {
         InitializeComponent();
      }
      private void InitializeComponent()
      {
         this.botonBuscar = new Button();
         this.cajaEntrada = new TextBox();
         this.labelSalida = new Label();
         this.SuspendLayout();
         //
         // botonBuscar
         //
         this.botonBuscar.Location = new System.Drawing.Point(8, 8);
         this.botonBuscar.Name = "botonBuscar";
         this.botonBuscar.TabIndex = 0;
         this.botonBuscar.Text = "Buscar";
         this.botonBuscar.Click += new System.EventHandler(this.botonBuscar_Click);
         //
         // cajaEntrada
         //
         this.cajaEntrada.Location = new System.Drawing.Point(96, 9);
         this.cajaEntrada.Name = "cajaEntrada";
         this.cajaEntrada.Size = new System.Drawing.Size(88, 20);
         this.cajaEntrada.TabIndex = 1;
         this.cajaEntrada.Text = "";
         //
         // labelSalida
         //
         this.labelSalida.Location = new System.Drawing.Point(8, 40);
         this.labelSalida.Name = "labelSalida";
         this.labelSalida.Size = new System.Drawing.Size(184, 23);
         this.labelSalida.TabIndex = 2;
         //
         // BusquedaLineal
         //
         this.AutoScaleBaseSize = new System.Drawing.Size(5, 13);
         this.ClientSize = new System.Drawing.Size(200, 69);
         this.Controls.AddRange(new Control[] {
                  this.labelSalida,
                  this.cajaEntrada,
                  this.botonBuscar});
         this.Name = "BusquedaLineal";
         this.Text = "BusquedaLineal";
         this.ResumeLayout(false);
      }
      static void Main()
      {
         Application.Run(new BusquedaLineal());
      }
      private void botonBuscar_Click( object sender,
         System.EventArgs e )
      {
         int datoBuscar = Int32.Parse( cajaEntrada.Text );
         int indiceElemento = BuscarLineal( a, datoBuscar );
         if ( indiceElemento != -1 )
            labelSalida.Text =
               "Encontrado en el indice " + indiceElemento;
         else
            labelSalida.Text = "Valor no encontrado";
      } // fin del metodo botonBuscar_Click
      // buscar valor dentro del array
      public int BuscarLineal( int[] array, int dato )
      {
         for ( int n = 0; n < array.Length; n++ )
         {
            if ( array[ n ] == dato )
               return n;
         }
         return -1;
      } // fin del metodo BusquedaLineal
   }
}

Descargar código fuente

En el siguiente ejemplo se muestra cómo realizar el ordenamiento de arreglos de enteros, usando el método burbuja en C#.

Ejemplo…

using System;
public class OrdenamientoBurbuja
{
  static void Main()
  {
     int[] a =  { 54, 6, 4, 8, 10, 12, 89, 68, 45, 37 };
     string salida = "Valores de los items originales\n";
     for ( int i = 0; i < a.Length; i++ )
        salida += "   " + a[ i ];
     // ordenar elementos del arreglo
     OrdenarBurbuja( a );
     salida += "\n\nValores de los items en orden descendente\n";
     for ( int i = 0; i < a.Length; i++ )
        salida += "   " + a[ i ];
     Console.WriteLine(salida);
  } // fin del metodo main
  // ordenar elementos de un arreglo con el metodo burbuja
  static public void OrdenarBurbuja( int[] b )
  {
     for ( int pasadas = 1; pasadas < b.Length; pasadas++ ) // pasadas
        for ( int i = 0; i < b.Length - 1; i++ )
           if ( b[ i ] > b[ i + 1 ] )      // comparar
              intercambio( b, i );         // intercambiar
  }
  // intercambio de dos elementos en un arreglo
  static public void intercambio( int[] c, int primero )
  {
     int temp;      // variable temporal para el intercambio
     temp = c[ primero ];
     c[ primero ] = c[ primero + 1 ];
     c[ primero + 1 ] = temp;
  }
}

Resultado…

Descargar código fuente

Ejemplos básicos de manipulación de arreglos en C#

Sumar elementos de un array

Sinopsis: hacer la sumatoria de los elementos de un arreglo.

using System;
class SumarArreglo
{
  // metodo Main
  static void Main( string[] args )
  {
     int[] a = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
     int total = 0;
     for ( int i = 0; i < a.Length; i++ )
        total += a[ i ];
     Console.WriteLine( "Suma de todos los elementos del array: " + total);
  } // fin de Main
} // fin de la clase SumarArreglo

Resultado…

Descargar código fuente

Creacion de histogramas

Sinopsis: crear un histograma (barras a base de asteriscos) a partir de unos datos.

using System;
class Histograma
{
  // metodo Main
  static void Main( string[] args )
  {
     int[] n = { 19, 3, 15, 7, 11, 9, 13, 5, 17, 1 };
     string salida = "Elemento\tValor\tHistograma\n";
     // construir salida
     for ( int i = 0; i < n.Length; i++ )
     {
        salida += "\n" + i + "\t\t\t" + n[ i ] + "\t\t";
        for ( int j = 1; j <= n[ i ]; j++ ) // imprimir una barra
           salida += "*";
     }
     Console.WriteLine( salida);
  } // fin Main
} // fin de la clase Histograma

Resultado…

Descargar código fuente

Estadisticas de notas de estudiantes

Sinopsis: apartir de un arreglo de notas (puntajes) identificar la frecuencia de cada una de ellas entre todos los estudiantes.

using System;
class EncuestaEstudiantes
{
  // metodo Main
  static void Main( string[] args )
  {
     int[] respuestas = { 1, 2, 6, 4, 8, 5, 9, 7, 8, 10, 1,
        6, 3, 8, 6, 10, 3, 8, 2, 7, 6, 5, 7, 6, 8, 6, 7,
        5, 6, 6, 5, 6, 7, 5, 6, 4, 8, 6, 8, 10 };

     int[] frecuencia = new int[ 11 ];
     string salida = "";

     // incrementar la frecuecia de para cada respuesta
     for ( int j = 0; j < respuestas.Length; j++ )
        ++frecuencia[ respuestas[ j ] ];

     salida += "Puntaje\tFrecuencia\n";

     // resultados
     for ( int puntaje = 1; puntaje < frecuencia.Length; puntaje++ )
        salida += puntaje + "\t\t" + frecuencia[ puntaje ] + "\n";

     Console.WriteLine( salida);

  } // fin Main

} // fin de la clase EncuestaEstudiantes

Resultado…

Descargar código fuente