En esta ocasión vamos a aprender usar el System Tray desde una aplicación hecha en Java. El System Tray o área de notificaciones, es el espacio en el escritorio en donde ‘residen’ aplicaciones que el sistema está ejecutando, pero que no tienen en foco de lo que estamos haciendo.

Antes se usaban librerías nativas + JNI para lograr esto, pero desde hace un tiempo se incluyeron en el API de Java 6 las clases SystemTray y TrayIcon (dentro del paquete java.awt) lo cual nos facilita mucho las cosas.

0. Entendiendo las clases SystemTray y TrayIcon + Prerrequisitos

Antes que nada, debes tener instalada una versión reciente del JDK6. La clase java.awt.SystemTray representa el System Tray del escritorio. Para manipular dicha clase es necesario obtener un objeto estático de esta usando el método SystemTray.getSystemTray() (es decir, no es posible crear instancias de dicha clase). Además, es necesario verificar que el uso de esta clase sea soportada en el sistema donde se ejecuta. Esto lo hacemos usando el método estático SystemTray.isSupported(). Si no hay soporte, este método retornará false. Si haces un llamado al método getSystemTray y tu sistema no está soportado, se lanzará la excepción java.lang.UnsupportedOperationException.

La instancia de SystemTray contiene uno o más TrayIcons, los cuales son añadidos usando el método add(java.awt.TrayIcon), y son eliminados con el método remove(java.awt.TrayIcon).

1. Ejemplo de uso

import java.awt.*;
import java.awt.event.*;
public class EjemploSystemTray {
    public EjemploSystemTray() {
        //se declara el objeto tipo icono
        final TrayIcon iconoSystemTray;
        //se verifica que el SystemTray sea soportado
        if (SystemTray.isSupported()) {
            //se obtiene una instancia estática de la clase SystemTray
            SystemTray tray = SystemTray.getSystemTray();
            //esta es la imagen de icono
            Image imagenIcono = Toolkit.getDefaultToolkit().getImage("icono.png");
            //este listener nos permite capturar cualquier tipo de evento
            //que se haga con el mouse sobre el icono
            MouseListener mouseListener = new MouseListener() {
                public void mouseClicked(MouseEvent e) {
                    System.out.println("Icono del System Tray - Mouse clicked!");
                }
                public void mouseEntered(MouseEvent e) {
                    System.out.println("Icono del System Tray - Mouse entered!");
                }
                public void mouseExited(MouseEvent e) {
                    System.out.println("Icono del System Tray - Mouse exited!");
                }
                public void mousePressed(MouseEvent e) {
                    System.out.println("Icono del System Tray - Mouse pressed!");
                }
                public void mouseReleased(MouseEvent e) {
                    System.out.println("Icono del System Tray - Mouse released!");
                }
            };
            //este listener se asociara con un item del menu contextual
            //que aparece al hacer click derecho sobre el icono
            ActionListener escuchadorSalir = new ActionListener() {
                public void actionPerformed(ActionEvent e) {
                    System.out.println("Saliendo...");
                    System.exit(0);
                }
            };
            //menu que aparece al hacer click derecho
            PopupMenu popup = new PopupMenu();
            MenuItem item = new MenuItem("Exit");
            item.addActionListener(escuchadorSalir);
            popup.add(item);
            //iniciamos el objeto TrayIcon
            iconoSystemTray = new TrayIcon(imagenIcono, "Prueba System Tray", popup);
            //este tipo de listener captura el doble click sobre el icono
            ActionListener accionMostrarMensaje = new ActionListener() {
                public void actionPerformed(ActionEvent e) {
                    iconoSystemTray.displayMessage("Titulo mensaje",
                            "Este es el contenido del mensaje!",
                            TrayIcon.MessageType.INFO);
                }
            };

            iconoSystemTray.setImageAutoSize(true);
            iconoSystemTray.addActionListener(accionMostrarMensaje);
            iconoSystemTray.addMouseListener(mouseListener);

            //se debe capturar una excepción en caso que falle la adicion de un icono
            try {
                tray.add(iconoSystemTray);
            } catch (AWTException e) {
                System.err.println("No es posible agregar el icono al System Tray");
            }
        }
        else
            System.err.println("Tu sistema no soporta el System Tray");
    }
    public static void main(String[] args) {
        new EjemploSystemTray();
    }
}

Así se ve en Linux (usando Gnome) y en Windows7:

Del ejemplo anterior veamos las líneas más importantes:

• Línea 8: verificamos que tengamos soporte.
• Línea 10: obtenemos una instancia de la clase SystemTray.
• Línea 46: creamos el icono que vamos a añadir.
• Línea 50: invocación del método displayMessage para mostrar globos de notificación.
• Línea 62: añadimos el icono al systray.

2. ¿Cómo usar Swing en vez de AWT?

Si te fijaste bien, el SystemTray es una clase que pertenece al paquete AWT… por alguna razón no se tuvo en cuenta Swing en todo esto. Es por ello que no podemos usar directamente JPopupMenu en vez de PopupMenu. Además, JPopupMenu tampoco es una subclase de PopupMenu por lo cual no podemos usar polimorfismo

Afortunadamente hay algunos trucos para hacerlo funcionar con Swing que nos proporciona varias ventajas: la apariencia del menú sería igual en cualquier sistema operativo, podemos añadir iconos a los items, etc.

El truco más sencillo del cual tengo conocimiento lo leí en el blog de Artem Ananiev, en un post llamado Using JPopupMenu in TrayIcon. He preparado entonces otro ejemplo sencillo en donde se muestra cómo lograr esto:

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class EjemploSystemTraySwing {
    public EjemploSystemTraySwing() {
        //se declara el objeto tipo icono
        final TrayIcon iconoSystemTray;
        //se verifica que el SystemTray sea soportado
        if (SystemTray.isSupported()) {
            //se obtiene una instancia estática de la clase SystemTray
            SystemTray tray = SystemTray.getSystemTray();
            //esta es la imagen de icono
            Image imagenIcono = Toolkit.getDefaultToolkit().getImage("icono.png");
            //este listener se asociara con un item del menu contextual
            //que aparece al hacer click derecho sobre el icono
            ActionListener escuchadorSalir = new ActionListener() {
                public void actionPerformed(ActionEvent e) {
                    System.out.println("Saliendo...");
                    System.exit(0);
                }
            };
            //menu que aparece al hacer click derecho
            final JPopupMenu popup = new JPopupMenu();

            //aniadir un menu con icono (swing)
            JMenuItem carita = new JMenuItem("casidiablo.net",  new ImageIcon("carita.png"));
            popup.add(carita);
            popup.addSeparator();

            //aniadir el item de salir
            JMenuItem item = new JMenuItem("Exit", new ImageIcon("salir.png"));
            item.addActionListener(escuchadorSalir);
            popup.add(item);
            //iniciamos el objeto TrayIcon
            iconoSystemTray = new TrayIcon(imagenIcono, "Prueba System Tray", null);
            iconoSystemTray.setImageAutoSize(true);
            //iconoSystemTray.addMouseListener(mouseListener);
            iconoSystemTray.addMouseListener(new MouseAdapter() {
                public void mouseReleased(MouseEvent e) {
                    if (e.isPopupTrigger()) {
                        popup.setLocation(e.getX(), e.getY()-50);
                        popup.setInvoker(popup);
                        popup.setVisible(true);
                    }
                }
            });
            //se debe capturar una excepción en caso que falle la adicion de un icono
            try {
                tray.add(iconoSystemTray);
            } catch (AWTException e) {
                System.err.println("No es posible agregar el icono al System Tray");
            }
        }
        else
            System.err.println("Tu sistema no soporta el System Tray");
    }
    public static void main(String[] args) {
        new EjemploSystemTraySwing();
    }
}

El resultado es algo como lo que aparece en la primera imagen que acompaña esta entrada. Importante tener en cuenta las líneas resaltadas (40 a 44) que es donde se hace la magia Como siempre, puedes descargar el código y probar tú mismo:

Descargar ZIP con ejemplos

Entre tanto trabajo, estudio y procrastinación me queda poco tiempo para publicar cosas… así que al menos iré poniendo pequeños tips que considero útiles. En esta ocasión un tip simple, redimensionar una partición con NTFS desde la consola. Para ello usaremos el comando ntfsresize que viene dentro del paquete ntfsprogs (Gentoo/Debian/Arch/FreeBSD/) o ntfstools (Ubuntu): http://www.linux-ntfs.org/

Instalación

Gentoo:

FreeBSD:

Ubuntu:

Debian:

Arch:

Uso…

El uso es bastante simple… para inspeccionar una partición, conocer cuanto espacio disponible tiene y cuanto es el mínimo/máximo que podemos asignarle ejecutamos lo siguiente:

Donde /dev/sda2 corresponde a la partición que queremos tratar. Supongamos que, por ejemplo, queremos redimensionar la partición a 34GB, ejecutamos lo siguiente para hacer un test de solo lectura:

El flag -n indica que NO se harán cambios reales sobre el disco, mientras que -s especifica el nuevo tamaño (k kilobytes, M para megabytes, G gigabytes). Si todo va bien con el test procedemos con el cambio real:

En esta entrada abordaremos un tema bastante interesante: cómo correr un programa en Java como servicio en Windows o demonio en UNIX/Linux. Puesto que el API de Java no proporciona nada para estos casos, utiliza

remos una librería llamada Java Service Wrapper. Dicha librería nos ofrece una serie de scripts y binarios preparados para diferentes sistemas operativos y arquitecturas, que nos permitirán correr nuestros programas como un servicio; además ofrece diferentes versiones: Profesional, Estándar y Comunity. En este caso usaremos la versión Comunity que es libre y gratuita.

La mejor manera de aprender a usar dicha librería es con un pequeño laboratorio, así que he preparado uno en donde explico la integración más simple que existe con Java Service Wrapper (existen 4 métodos; unos más avanzados que otros). La integración sencilla que he escogido nos permitirá ejecutar como servicio una aplicación que ya esté creada (probablemente ya empaquetada en un .jar) y a la que no podemos o es difícil hacerle modificaciones. Esta es la manera más sencilla de hacerlo, sin embargo tiene una desventaja: al detener el servicio se envía directamente un System.exit() a la JVM por lo que la aplicación no se cerrará limpiamente.

Si quieres integrar tu aplicación de una manera más segura y estás en la capacidad de prepararla para ello, podrías intentar la integración avanzada en la que utilizas el API de Java Service Wrapper para implementar métodos de inicio, pausa y detención del servicio [Para este caso utilizaremos una aplicación de ejemplo que recibe un archivo como parámetro y escribe en él información sobre la memoria del sistema, cada 60 segundos. He escogido este ejemplo porque posee varios aspectos interesantes: requiere de librerías externas (tanto JARs como librerías nativas [.so, dll, etc.]) y recibe parámetros.

Puedes descargar la aplicación de ejemplo de haciendo clic aquí. Si la ejecutáramos de manera convencional veríamos algo de este tipo:

Como puedes ver se trata de una aplicación de consola común y corriente. La aplicación consta básicamente de:

• El ejecutable servicio.jar ubicado en el directorio bin/
• La librería sigar.jar en el directorio lib/
• Las librerías específicas de cada arquitectura de sigar en lib/

Pasos para la integración

Lo primero es descargar el paquete de Java Service Wrapper y descomprimirlo. Supondremos que el directorio donde se encuentra Java Service Wrapper es $RUTA_JSW y que el directorio de la aplicación que  vamos a convertir en servicio es $RUTA_APP.

1. Copiamos los siguentes archivos al directorio bin de nuestra aplicación de ejemplo…

UNIX/Linux

El archivo $RUTA_JSW/bin/wrapper podría no existir; por lo tanto lo que debes copiar es el archivo wrapper-xxx específico para tu plataforma. Por ejemplo, en este caso estoy usando Gentoo Linux de 64bits por lo tanto copiaré el archivo $RUTA_JSW/bin/wrapper-linux-x86-64.

Windows

2. Renombramos algunos archivos…

UNIX/Linux…

Ahora debes renombrar el script sh.script.in con el nombre de la aplicación con la que haremos la integración y darle privilegios de ejecución. En este casó se llama simplemente “servicio”:

Windows

Ahora debes renombrar los archivos .bat  para que concuerden con el nombre de la aplicación con la que haremos la integración. En este casó se llama simplemente “servicio” (lo puedes hacer usando el explorador si no te gusta usar la consola, pero a mi me daría pena):

3. editar archivo de configuración

Editamos el archivo wrapper.conf y lo dejamos en el directorio $RUTA_APP/conf/. El archivo para este ejemplo tendrá el siguiente contenido (importante! lee la explicación si usas Windows):

# Comando de Java
wrapper.java.command=java
# Clase que ejecutara el Wrapper
wrapper.java.mainclass=org.tanukisoftware.wrapper.WrapperSimpleApp
# Librerias necesarias para ejecutar el programa
wrapper.java.classpath.1=../lib/wrapper.jar
wrapper.java.classpath.2=servicio.jar
# Java Library Path (ubicacion de las librerias wrapper.dll o wrapper.so)
wrapper.java.library.path.1=../lib
# Java Bits.  On applicable platforms, tells the JVM to run in 32 or 64-bit mode.
wrapper.java.additional.auto_bits=TRUE
# Parametros del programa
wrapper.app.parameter.1=net.casidiablo.servicio.Servicio
wrapper.app.parameter.2=/tmp/log
#********************************************************************
# Wrapper General Properties
#********************************************************************
# Allow for the use of non-contiguous numbered properties
wrapper.ignore_sequence_gaps=TRUE
# Title to use when running as a console
wrapper.console.title=servicio
#********************************************************************
# Wrapper Windows NT/2000/XP Service Properties
#********************************************************************
# Name of the service
wrapper.name=jgossip
# Display name of the service
wrapper.displayname=Servicio
# Description of the service
wrapper.description=Monitor de memoria
# Mode in which the service is installed. AUTO_START or DEMAND_START
wrapper.ntservice.starttype=AUTO_START
# Allow the service to interact with the desktop.
wrapper.ntservice.interactive=false

Explicación del archivo de configuración:

• wrapper.java.command=java es el comando para ejecutar java. En este caso es simplemente java porque estoy en Linux y además tengo configurado correctamente el path. En Windows podría ser algo como: c:\archivos de programa\java\jdk1.6\bin\java.exe
• wrapper.java.mainclass=org.tanukisoftware.wrapper.WrapperSimpleApp indica el archivo a ejecutar es la clase WrapperSimpleApp que se usa en la integración sencilla. Esta clase envoltorio es la que permite ejecutar la aplicación como servicio.
• wrapper.java.classpath.1=../lib/wrapper.jar
wrapper.java.classpath.2=servicio.jar indican las rutas o archivos del classpath.
• wrapper.java.library.path.1=../lib indica el directorio donde se encuentran las librerías a usar.
• wrapper.app.parameter.1=net.casidiablo.servicio.Servicio
wrapper.app.parameter.2=/tmp/log estos son los parámetros que se pasarán al programa. Importante: como estamos haciendo la integración simple, el primer parámetro debe ser la clase que contiene el método main de nuestra aplicación.
• wrapper.name=jgossip esta opción es para Windows y define el nombre del servicio en el sistema.
• wrapper.ntservice.starttype=AUTO_START si estás en windows, define si el servicio quedará configurado para iniciar automáticamente.

4. Probar/Instalar el servicio…

Ahora veremos cómo podemos probar la aplicación para asegurarnos que ha quedado bien configurada antes de proceder con la instalación.

UNIX/Linux

Ejecutamos el script ‘servicio’ que configuramos en el paso 1 y 2 con el parámetro console:

Deberías ver algo como:

Lo detienes presionando Ctrl+C. Ahora, si queremos probarlo como demonio basta con ejecutar los comandos típicos de un demonio en UNIX/Linux:

Para instalarlo basta con crear un enlace simbólico del script en el directorio /etc/init.d y añadirlo al listado de servicios a iniciar; por ejemplo:

Windows

Para instalarlo en Windows basta con ejecutar el archivo InstallServicio-NT.bat. Puedes verificar que fue instalado correctamente accediendo a la consola de administración de servicios de NT (ejecutas el comando services.msc):

Fuentes y descargas

Aunque en esta entrada no explico cómo hacer la integración avanzada, he preparado un ejemplo completo que puedes descargar en el listado de abajo.

• Puedes encontrar más documentación en la página oficial del proyecto
• Descargar el laboratorio de esta entrada
• Descargar el código fuente del laboratorio
• Descargar código fuente y laboratorio de la integración avanzada

Hola amigos… he grabado un pequeño vídeo en donde enseño cómo ejecutar varios sistemas operativos REALES, es decir, que no son virtuales, al mismo tiempo usando VirtualBox. Por ejemplo, si tienes instalado Windows XP, Ubuntu y Fedora, y en cada uno tienes aplicaciones que usas a diario, podrías ejecutar Windows XP desde Ubuntu sin necesidad de tener que reiniciar el equipo.

Esto tiene una gran ventaja frente al típico entorno en el cual tienes máquinas virtuales instaladas ya que, cuando realmente quieras usar el otro sistema operativo, lo ejecutas directamente en tu máquina sin las limitaciones de RAM o aceleración gráfica. Es más o menos lo que explicaba en esta entrada, en donde lo hacia con Windows XP. Pero puesto que algunos han tenido problemas con eso, y otros más me han pedido algo de información más detallada, mejor dejar todo registrado en este vídeo.

Como siempre lo he subido en Blip.tv, Youtube y Vimeo. El vídeo es completamente libre, puedes darle el uso que desees; si deseas el vídeo original para cualquier propósito me contactan por correo.

Muchas veces tenemos un sistema Windows instalado/configurado/personalizado antes de instalar nuestra distro favorita, y desearíamos no perder dicho trabajo y poder a la vez ejecutar aplicaciones nativamente para Windows desde nuestro querido Linux.

Lo que podemos hacer en este caso es crear una imagen de acceso virtual de nuestro disco duro, y con ella ejecutar Windows desde Linux. 

Paso 1: crear imagen del disco duro

En realidad lo que se crea es un especie de “acceso directo” al disco, es decir, NO crea una imagen con los datos del disco duro sino acceso al mismo. 

Paso 2: añadir el disco duro virtual a VirtualBox

Abre VirtualBox y selecciona Archivo->Administrador de discos virtuales (File->Virtual Disk Manager en inglés), clic en el botón Añadir (Add) y seleccina el archivo que acabas de crear.

Paso 3: crear una nueva máquina virtual

Clic en el botón Nueva (New) y Siguiente (Next) en el asistente de creación de máquinas virtuales. Digita WinXP como nombre y selecciona Windows XP como tipo de máquina virtua, clic en Siguiente (Next).

Selecciona la cantidad de memoria RAM que deseas otorgar a la máquina virtual.

Ahora es donde debemos seleccionar el disco duro que hemos creado, así que has clic en Existente (Existing) y selecciona el disco duro que añadiste en el paso 2. Clic en Siguiente y luego en Finalizar.

Paso 4: configurar la nueva máquina virtual

Selecciona la máquina virtual WinXP, clic derecho y Configuración (Settings). Allí habilita el audio, los Puertos seriales (Serial Ports), los Puertos USB (USB ports), asigna el drive CD/DVD a la unidad local, y añade los Directorios Compartidos (Shared Folders) que sean necesarios, etc.

Ahora simplemente has clic en Iniciar (Start) y verás el menú de tu grub (o lilo), donde podrás seleccionar y ejecutar Windows XP (no es recomendable ejecutar el SO Linux que ya está corriendo). Recuerda que todos los cambios que realizes sobre la máquina virtual se verán reflejados en el SO original.

Problemas y soluciones

Uno de los problemas normales que pueden ocurrir, es al momento de crear el disco virtual. En la mayoría de los casos se trata de problemas de permisos, y tenemos algunas opciones para solventarlo:

1. Realizar todo como root (NO RECOMENDADO)
2. Cambiar los permisos de los discos duros:
   sudo chmod 666 /dev/sdb2

   (Más o menos recomendado)

3. Crear un nuevo usuario con los permisos indicados:
   sudo adduser rawvb –ingroup MYGROUP –no-create-home
   sudo adduser rawvb disk
   sudo adduser rawvb vboxusers

   Luego puedes crear un script que ejecute VirtualBox adecuadamente:

   #! /bin/bash
   VBUSER=rawvb # nombre del usuario que es miembro del grupo disk
   VM_NAME=xpraw # nombre de la maquina virtual      

   chmod -R g=u /home/$USER/.VirtualBox # asegurarse que el otro usuario tenga acceso a la configuracion del VirtualBox
   xauth extract /home/$USER/cookieTmp $DISPLAY
   chmod g+r /home/$USER/cookieTmp
   sudo -u $VBUSER XAUTHORITY=/tmp/.Xauthority_$VBUSER xauth merge /home/$USER/cookieTmp
   rm /home/$USER/cookieTmp
   sudo -u $VBUSER XAUTHORITY=/tmp/.Xauthority_$VBUSER VBOX_USER_HOME=/home/$USER/.VirtualBox VBoxManage startvm $VM_NAME&

   Es la manera RECOMENDADA aunque es un poco más larga. Es tu desición.

Otro problema puede ser que Windows no arranque (pequeño problema ), lo cual se puede deber al hardware, por ejemplo: supón que tienes una nVidia y haces uso de ella en Windows… luego VBox (que no tiene soporte para aceleración gráfica) carga Windows con su hardware emulado, entonces Windows dice ¿Qué demonios pasa? ¿No pillo bien el hardware? ¿Qué ha pasado? Bueno, mejor ni arranco, que se las apañe el usuario solito. En esos casos no podrás ¿disfrutar? de tu Windows.

En lo personal, me ha funcionado en uno de dos computadores donde hice la prueba. Aunque eso no dice mucho, así que lo mejor será leer sus comentarios.

Actualización: me envía Pablo Derendinger los pasos que el siguió y que le funcionaron… se basó en esta guía pero añadió un par de pasos que seguro resultarán útiles a algunos usuarios con problemas.

No suelo usar la suite ofimática de Windows Office 2007, pero siempre me gustó la fuente que trae por defecto: Calibri. Me parece bastante elegante, y aunque por obvias razones no son libres me gusta tenerlas a mano en mi equipo. Al grano!

En cualquiera de los casos necesitamos el paquete PowerPoint Viewer de Microsoft.

Instalarlas sin necesidad de wine

1. Instalar cabextract. En Fedora o openSuse, correr este comando: sudo yum -y install cabextractEn Debian o Ubuntu correr este comando: sudo apt-get install cabextract
2. Descargar el PowerPoint Viewer 2007.
3. Extraer el .exe: cabextract -F ppviewer.cab PowerPointViewer.exe
4. Preparar un direcotorio para instalar las fuentes: sudo mkdir /usr/share/fonts/vista
5. Extraer las fuentes: sudo cabextract -F '*.TT?' -d /usr/share/fonts/vista ppviewer.cab
   Tip: Puedes sustituir /usr/share/fonts con ~/.fonts si no tienes permisos administrativos.
6. Actualizar el caché: fc-cache -fv

Instalarlas usando wine

1. Instalar wine. En Fedora o openSuse, correr este comando: sudo yum -y install wineEn Debian o Ubuntu correr este comando: sudo apt-get install wine
2. Descargar PowerPoint Viewer 2007.
3. Instalar el visor: wine PowerPointViewer.exe
4. Copiar las fuentes: sudo mkdir /usr/share/fonts/vista
cd ~/.wine/drive_c/windows/fonts/
sudo mv {CALIBR,CAMBRIA,CANDARA,CONSOLA,CONSTAN,CORBEL}*.TT? \
/usr/share/fonts/vistaTip: Puedes sustituir /usr/share/fonts con ~/.fonts si no tienes permisos administrativos.
5. Actualizar el caché: fc-cache -fv

Licencia de las fuentes:

You may use the fonts that accompany the PowerPoint Viewer only to display and print content from a device running a Microsoft Windows operating system.

Fuente: OpenOffice Ninja