Me llena de orgullo y satisfacción anunciar la disponibilidad de mi web personal www.josejavierlop.es. El dominio y alojamiento corre por cuenta de ZP, al menos este primer año, gracias al proyecto Jovenes en red y a Hostinet, que ha sido el proveedor que he elegido para darme el servicio.

La página nace sin grandes pretensiones, mi intención es tener mi sitio publico en la red. En cuanto al diseño, es propio y me ha llevado unos minutos de photoshop y unas pocas horas de CSS. Por raro que pueda parecer, nunca había hecho una web HTML + CSS, y me ha parecido una experiencia muy interesante y con grandísimas posibilidades. El pero que le he encontrado: puesme he encontrado con diferencias de visualización entre Firefox 2 e Internet Explorer 7 que aún tengo que corregir, y eso que la página es sencillisima.

Nada de esto habría sido posible sin los tutoriales de CSS de mi compañero Ricardo y los del W3C, que recomiendo a todo el mundo, y sin el apoyo artístico de mi novia. Y bueno… estoy abierto a críticas. Sed buenos

En cuanto a gadgets, lo que está petando ahora son los ultraportátiles. Abanderados por el deseado ACER EEEPC: Un portatil con una pantalla de 7 pulgadas capaz de sacar una impresionante resolución de 800×480. A ASUS le han seguido el resto de fabricantes y parece que la batalla definitiva (en España) se librará en junio, que aparecerán una docena de fabricantes ofreciendo básicamente portátiles de 300€ con pantalla de 7″ y de 400€ con pantallas de 8,9″ ofreciendo resoluciones de 1024×600.

Estos ultraportátiles, que no cuentan con mucha capacidad de cálculo, tienen la función principal de navegar, consultar el correo y va destinado a público objetivo joven, por su estética, precio y funcionalidad.

Sin embargo, pese a que prácticamente lo único que podemos hacer con esos dispositivos será ver páginas web, este cometido no lo cumple nada bien, puesto que la mayoría de las webs están pensadas para resoluciones de al menos 800×600.

El tiempo dirá si el concepto triunfará y, de ser así, si será trabajo de los navegadores el aumentar mejorar la experiencia de la navegación, haciéndola más ergonómica al estilo del iPhone o bien si arrastrará a los sufridos diseñadores web a hacer que las páginas se ajusten a estas resoluciones de mierda.

Como siempre ocurre el futuro se decidira en EEUU así que conviene tener un ojo siempre puesto ahi.

Uno de los problemas con los que, si trabajamos con JasperReports, acabamos encontrándonos inevitabemente es el de falta de memoria para ejecutar un informe mediano-grande. Básicamente nos puede ocurrir que al lanzar un informe nos salte un error de java java.lang.OutOfMemoryError, porque en el proceso de FILL (Obtener los datos y rellenar la plantilla del informe con estos) nos hemos quedado sin memoria heap.

En un pprincipio se nos puede ocurrir aumentar esta memoria, cambiando las propiedades de la máquina virtual para que en lugar de abrir con 64 megas abra con, que se yo, 512 megas. Pues bien, es evidente que esa no es la solución, y a poco que googleemos nos encontramos con este artículo en el que nos enseñan a generar informes grandes, abordando el problema de dos maneras: La paginación y la virtualización.

Paginación se refiere a obtener el informe en trozos, en lugar de recoger toda la información de golpe, pero como al final los datos se tienen que mostrar juntos en un único informe, nos introducen la virtualización. La virtualización es una técnica que consiste en serializar los datos, para no saturar la memoria heap.

El código necesario para incluir virtualización, ojo, a costa de perder rendimiento, es el siguiente:

String temporalPath = System.getProperty("user.home") + File.separator + "tmp";
 //creando el directorio temporal
File temporalDir = new File(temporalPath);
if (!temporalDir.exists() || !temporalDir.isDirectory()) {
    temporalDir.mkdir();
}

// crear el virtualizador
JRFileVirtualizer virtualizer = new JRFileVirtualizer(10, temporalDir); Map params = dlg.getReportParameters();
params.put(JRParameter.REPORT_VIRTUALIZER, virtualizer);

En las primeras cuatro líneas creamos el directorio en el que vamos a almacenar temporalmente los datos. Obtenemos en el ejemplo una referencia a “user.home” que en windows será documents and settings/NOMBRE_USUSARIO, en linux /home/NOMBRE_USUARIO y en otros sistemas vaya usted a saber. A esa ruta le concatenamos /tmp y nos aseguramos de que exista.

Una vez que tenemos el directorio en el que queremos que se metan los datos creamos un virtualizador de fichero JRFileVirtualizer pasándole como parámetro 10 (Indica que generará archivos de 10 ks) y el directorio que hemos creado.

Finalmente añadimos el parámetro con key: JRParameter.REPORT_VIRTUALIZER y value: nuestro objeto virtualizador a los parámetros que le pasaremos al jasper para generar el informe. Si recordamos JasperFillManager.fillreport(jasperreport, parametros).

Únicamente tenemos que acordarnos de que esos archivos temporales ocupan espacio. Podríamos borrarlos usando

temporalDir.delete();

Con esto seguro que no se nos resiste ningún informe, por grande que sea. (Dudas y sugerencias donde siempre…)

El sitio web wikio organiza un concurso navideño para promocionarse en el que regala iPhones, en plural. Uno para el ganador del sorteo y otro para el referente del ganador.

Yo ya estoy inscrito y el que quiera ser mi ahijado en el sorteo no tiene más que apuntarse a través de mí. ¿Por qué entrar al sorteo sin padrino, pudiendo hacer participe de tu suerte al abajo firmante?.

Mucha suerte!

En el artículo anterior comentaba la posibilidad que ofrece la aplicación iReport, desde su versión 0.3.1, de incluir aplicaciones propias en forma de plugins, o conectores en la versión traducida al castellano.

El proceso es tan sencillo que se explica en la documentación de iReport en una única página, pero vamos a ver paso a paso como se hace.

• Lo primero que necesitamos es descargarnos el iReport, aunque se supone que este ya lo tenemos, e instalarlo en nuestro ordenador (c:\Archivos de programa\JasperSoft\iReport-2.0.2\ en mi caso y a partir de ahora IREPORT_PATH) .
• Una vez instalado buscaremos en IREPORT_PATH/lib una librería lamada iReport.jar
• Ahora ya nos podemos crear un proyecto e incluir esa librería en el classpath.
• Crearemos ahora la clase que arrancará nuestra pequeña aplicación. Esta tendra que extender de IReportPlugin.(Se puede consultar en el enlace)
• Como se ve en la clase, lo único que tenemos que implementar si o si es el método abstracto call(), que es el que ejecutara el iReport. En el ejemplo de iReport este sería el código del método:

	 public void call() {
    		javax.swing.JOptionPane.showMessageDialog(this.getMainFrame(), "Hello from plugin!");
  	 }

• Con nuestro super plugin nos podemos crear un jar que dejaremos en la carpeta IREPORT_PATH/lib.
• Solo nos queda crear el XML que describe el plugin, en el ejemplo que estamos viendo es este:

	<iReportPlugin
 		name="Example 1"
 		class="it.businesslogic.ireport.plugin.examples.HelloWorld"
		loadOnStartup="false"
		hide = "false"
		configurable = "true">
		<IconFile>/it/businesslogic/ireport/icons/menu/new.gif</IconFile>
		<Description>This example shows how to create a very simple plugin for iReport.</Description>
	</iReportPlugin>

• Donde:

  	class="it.businesslogic.ireport.plugin.examples.HelloWorld" 

  es la clase que hemos creado y

  	<IconFile>/it/businesslogic/ireport/icons/menu/new.gif</IconFile>

  es el icono, que puede estar en nuestro jar o en el del iReport como en el ejemplo.

• Una vez creado el xml de descripción del plugín se coloca en IREPORT_PATH/plugin y se inicia el iReport. Debería aparecer ya nuestro plugin (El mio es el del monito)

• Que al ejecutarlo nos abrirá el plugin

Hasta aqui el ejemplo de la web. Para mi es interesante destacar el método getMainFrame() que nos devuelve un objeto MainFrame. Ese objeto es el gui de iReport, al que tenemos acceso total en nuestro plugin. El gui es una aplicación MDI (Multiple Documment Interface), al estilo Word y del que podemos obtener cada uno de los formularios abiertos o el activo de la siguiente manera:

	getMainFrame().getActiveReportFrame();

También podemos obtener el informe de ese Frame:

	Report r = getMainFrame().getActiveReportFrame().getReport();

	r.getFilename();

O las conexiones configuradas en la aplicación:

	List lista = getMainFrame().getConnections();

Y así con cada uno de los elementos de la aplicación. Es importante comentar que los objetos que vamos a obtener son propios de iReport y no de Jasper, es decir: con getParameters() obtendremos un array de JRParameter, pero de tipo it.businesslogic.ireport.JRParameter y no de tipo net.sf.jasperreports.engine.JRParameter.

Pues con esto, que ha sido como no decir nada, acabo el mini-tuto de crear plugins. El resto lo tendreis que descubrir experimentando, que es más divertido.

Desafortunadamente la documentación del código de iReport brilla por su ausencia (Javadoc, java que?), igual porque existe un libro a la venta.

Afortunadamente, iReport es open source, con lo que tenemos el código fuente completito en IREPORT_PATH/src, con lo que ¿Para qué queremos más?.

Que ustedes lo plugineen bien.

Cuando empece a utilizar iReport, la aplicación para diseñar informes para el motor de informes JasperReports, este andaba por la versión 0.4.1, y su logo era un gato apestoso.

Apestoso como el iReport en sí, que era lento, inestable y muy poco amigable. Con eso no quiero decir que fuera una mala aplicación, todo lo contrario, ya que se trataba de una aplicación libre, hecha por un único programador y nos ahorraba la taréa de generar los informes escribiendo XML directamenté (Nooooo, jamaaaas!!). Ahora en cambio, y en la versión 2.0.2 a día de hoy (porque evolucionan super rápido), iReport se ha convertido en una aplicación bonita, estable y amigable, y cuando oigo a mis compañeros echar pestes del iReport me siento como el abuelo cebolleta recordando mis duros inicios. También es verdad que JasperReports han formado una empresa y han comprado iReport, y se nota que el equipo de desarrollo ya no es únicamente el señor Giulio Toffoli, creador del proyecto.

Pues bien, en esa época, me toco asumir la taréa de montar un sistema de informes dinámicos, construidos en tiempo de ejecución y además incluir un diseñador de informes propio, bastante peor este que el iReport, además de, por supuesto, los informes típicos de cualquier aplicación. En un primer momento evalué distintas alternativas, tanto de pago como gratuitas (y libres incluso) y mi elección fué JasperReports + iReport. Y a la vista de los resultados que obtuve en el proyecto y la trayectoria que ha seguido este motor, creo que hice la elección correcta.

Como todo el mundo sabe, los informes de JasperReports se montan en un diseño (JasperDesign) que se compila en un binario (JasperReport) y este se rellena de datos en base a una conexión a un almacen de datos. El hecho de tener que compilar el informe cuando se cambia el diseño no supone mucha molestia, el caso es que como en esa época era un proyecto tan vivo, un cambio de versión suponía recompilar todos los diseños a esa versión (aunque no se hubiera modificado nada). Para esta tediosa taréa me cree una apliaccioncilla que te permitía seleccionar los informes y compilarlos en grupo. Al poco de tener esta aplicación creada, aparecio una versión de iReport con un plugin incorporado que se llamaba massive compiler, su funcionalidad es evidente y a mi me sirvió para descubrir el soporte para plugins de iReport (que por lo visto existe desde su versión 0.3.1).

No ha sido hasta ahora cuando me ha surgido la necesidad de crear otro un plugin para iReport, y en la siguiente entrega describiré brevemente este proceso.

Segun tecnorati, cada día se crean 80000 blogs nuevos, hace no mucho cree yo este blog, en el que pretendo comentar temas de programación, tecnología, ingeniería… y cerre otros dos que tenía en desuso. Pero este blog era, hasta hoy, un callejón sin salida en la blogosfera (que palabra mas asquerosa), sin ningún link a ninguna parte. Así que me he permitido la libertad de enlazar a mis amigos, además de compañeros de trabajo, Miguel, Urko, Angel y Ricardo en la sección de blogroll. Agradeciendoles además que enriquezcan la web con sus interesantísimos artículos.

Termino este insulso post recomendando la visita de estos sitios a mis lectores si es que los tengo.

Hoy multitud de sitios se hacen eco de esta noticia: “Google lanza el SDK de Android“. El SDK o Software development kit para programar en la plataforma Android, que es una plataforma para móviles apoyada por muchos fabricantes de móviles y operadores de telefonía, pero que curiosamente no cuenta con ningún dispositivo que soporte la plataforma, más alla del emulador de móviles que incluye el SDK.

Con Android, Google se posiciona en la lucha de acaparar el mercado de aplicaciones para móviles. Frente a Google están Flex mobile de Adobe, la plataforma de apple con su iPhone, el próximo JavaFX de Sun, Symbian y el antiguo Java ME. Existen algunas alternativas menos conocidas como OpenMoko (vaya nombre más desafortunado) que personalmente pienso que permanecera siendo minoritaria aunque a diferencia de Android ya existe un móvil que lo soporta.

Un par de cosas me llaman a empezar a programar con Android (además de estar liderado por Google con las garantías que eso implica). La primera es que esta construido sobre Java, utilizando un subconjunto de JavaME y JavaSE más librerías propias y ejecutandose sobre una máquina virtual propia “Dalvik”. Y la segunda es que Google va a invertir 10 millones de dólares en premios para desarrollos en esta plataforma. Copiopego de Barrapunto:

Google ha creado el concurso “Android Developer Challenge”, en el que se repartirán 10 millones de dólares para las aplicaciones móviles creadas con esta plataforma. El concurso se desarrollará en dos fases. En la primera de ellas, que finalizará el 3 de marzo, los 50 mejores proyectos recibirán 25.000 dólares cada uno para que sus creadores siguen desarrollándolos. De los que se finalicen con estas ayudas, los diez mejores recibirán 275.000 dólares cada uno y los 10 siguientes 100.000 dólares cada uno.

Como apunta alguien también en Barrapunto, eso suma 5 millones, los otros 5 se repartirán en la segunda fase ¿?

De cualquier manera, si saco algo de tiempo, probaré a programar en Android y ¿Quién sabe? igual salgo de pobre.

Las anotaciones son un mecanismo para dotar a las clases de Meta información o auto información. Estas ya existían en versiones de java anteriores y de hecho se usaban, por ejemplo para generar el javaDoc (@Deprecated). Pero desde la versión 1.5 (Tiger! oh yeah) se han convertido en una parte Tipada del lenguaje y podemos trabajar con ellas tanto en tiempo de compilación como en tiempo de ejecución.

Anotar una porción de código nos sirve para procesarla de alguna manera en algún script, herramienta de despliegue o de diseño, para hacer uso de ellas en un framework, para trabajarlas distintas por un compilador…

Decía que las anotaciones se pueden trabajar en tiempo de ejecución. La forma de hacerlo sería usando el API de reflection, que se ha completado en Java 5 para tener acceso a las anotaciones.

Por ejemplo en la clase Class tenemos:

<A extends Annotation> A getAnnotation(Class<A> annotationClass)

Annotation[] getDeclaredAnnotations()

boolean isAnnotation()

Tenemos métodos similares en las clases de reflexión java.lang.reflect.Field, java.lang.reflect.Method… Puesto que las anotaciones pueden ir a cada uno de estos niveles.

Además la plataforma java incluye un herramienta apt para trabajar con anotaciones. %JAVA_HOME%/bin/apt

Para distinguir las anotaciones, estas vienen precedidas siempre de una arroba (@ Toma!). Y se pueden clasificar en 3 tipos:

• Marker annotations: Anotaciones que no reciben ningún parámetro. Marcan algún elemento. La única información que nos da esta anotación es que se tiene o no se tiene.
• Normal annotations: Anotaciones que reciben argumentos en forma de pares nombreParametro=valorParametro
• Single member annotations: Anotaciones que sólo tienen un miembro y este se llama value, no necesitan indicar el nombreParametro, solo el valorParametro.

Además estan las built in annnotations, es decir, las que ya forman parte del lenguaje, que en la versión java SE5 son 3:

• Overrides: Indica que el método esta siendo sobreescrito, tenemos un error de compilación si el método no es sobreescrito. (Si nos equivocamos al teclearlo).
• Deprecated: Indica que el método esta deprecado y no debería usarse y nos genera un warning en compilación.
• SupressWarnings: Recibe una lista de argumentos y le indican al compilador que no muestre los warnings de los tipos pasados como argumento. (“all”,”checked”,”finally”).

Las anotaciones pueden a su vez estar anotadas, es decir, en la definición de una anotación podemos anotarlas usando meta-anotaciones.

Estas son:

• Target: Indica sobre que elementos puede usarse la anotación. Recibe un array de argumentos y las posibilidades son: TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE, ANNOTATION_TYPE, PACKAGE.
• Retention: Indica el alcance de la anotación. Las posibilidades son:
  • SOURCE: La anotación sólo existe en el fuente, no en la clase compilada.
  • CLASS: Por defecto. La anotación existe en la clase pero la maquina virtual la ignora en ejecución.
  • RUNTIME: La máquina virtual tiene acceso a ella y es necesaria si queremos acceder reflexivamente a ella.
• Inherited: Indica que la anotación la heredan las subclases.
• Documented: Indica que las herramientas de documentacion tipo javaDoc tienen que documentarla.

Así pues la forma de crear un Annotation Type (Lo que sería la Clase de los objetos anotación) utilizaremos la sintaxis:

@Meta-anotacion1(miembros)

@Meta-anotacion2(miembros)

…..

modificadores @interface NombreTipoAnotación{

TipoMiembro1 nombreMiembro1();

TipoMiembro2 nombreMiembro2() default valorPorDefecto;

…

}

Más claro lo tenemos en el ejemplo de la anotación built-in SupressWarnings:

package java.lang;

import java.lang.annotation.*;

import java.lang.annotation.ElementType;

import static java.lang.annotation.ElementType.*;

@Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR,

LOCAL_VARIABLE})

@Retention(RetentionPolicy.SOURCE)

public @interface SuppressWarnings {

String[] value();

}

Como cosa curiosa, al construir tipos de anotaciones estamos usando la notacion @interface aunque en realidad lo que ocurre es que estamos extendiendo de la intefaz java.lang.annotation.Annotation, Pero si la extendieramos directamente NO conseguiríamos una anotación.

 

 

BIBLIOGRAFÍA:

 

Annotations java.sun.com

Novedades en J2SE 5.0 (Tiger), Iker Hurtado Díaz de Cerio

Learn to Use the New Annotation Feature of Java 5.0

Recientemente he tenido que adaptar una aplicación para ser usada por personas invidentes, a eso se le llama accesibilidad, y aunque parece que vaya a ser un trabajo de chinos en realidad no lo es tanto.

Las personas invidentes utilizan un software de lectura de pantalla, es decir, una aplicación que con un sintetizador de voz (software) lee la información que se muestra en la pantalla utilizando la tarjeta de sonido del ordenador (lo normal es que utilicen cascos porque es realmente molesto). En la O.N.C.E. utilizan jaws, y con este es con el que me ha tocado lidiar a mi. El invento por si mismo ya posibilita a un invidente trabajar con aplicaciones windows, correo, navegadores y demás programas de uso común. Pero para que una aplicación java swing pueda ser interpretada por jaws hacen falta varias cosas:

Lo primero es instalar el propio jaws (30 días tenemos de prueba) y java bridge, un driver de sun para que el sistema operativo pueda tener acceso a las aplicaciones java y que por suerte es gratuito.

Además hay que dotar a los componentes de un texto “accesible” que es el que jaws leera. Esto lo hacemos asi:
componente.getAccesibleContext().setAccesibleName("Hola invidente");

Conviene también asociar las etiquetas de texto al componente al que hace referencia (jTextFields,jTextAreas, jComboBoxes …). Tan facil como esto:
miLabel.setLabelFor(miComponente);

Para terminar, es importante que el foco pueda llegar a todos los componentes y que no se nos pierda por ahi, y que haya accesos rápidos para abrir, cerrar ventanas, entrar en menús…:
boton.setMnemonic(KeyEvent.VK_A); //Acceso con la tecla A

Coser y cantar.