MATLAB, como no podía ser de otra manera, es una herramienta muy útil para el desarrollo ágil de algoritmos, probarlos y así, cuando nos decidamos a pasarlos a un lenguaje distinto que nos permita su mejor explotación, estemos seguros de que va a funcionar, que no hemos implementado funciones que realmente no nos hacían falta y que no vamos a dar demasiados pasos en falso.

Nosotros, los que estudiamos Ingeniería de Telecomunicaciones, estamos bastante acostumbrados a trabajar con MATLAB pero, al menos en mi caso, siempre me había visto tratando señales de audio o de radiación, nunca imágenes o vídeos. Pero ayer, en un intento de hacer algo diferente (mostrar la evolución de una imagen conforme se va comprimiendo), se me ocurrió la idea de mostrar cada una de las imágenes obtenidas por mi algoritmo como un frame de vídeo en una película.

Tras investigar un poco, puedo decir que crear un vídeo *.avi usando MATLAB, es de lo más sencillo, es más, sólo tenemos que escribir cuatro líneas (aunque usa podrá repetirse tantas veces como frames tengamos en nuestro vídeo).

Paso 1

Creamos una variable en la que insertaremos los distintos frames:

movie = avifile('video.avi', 'fps', 10, 'compression', 'none');

Esta función tiene la siguiente especificación:

aviobj = avifile(filename, ParameterName, ParameterValue)

Es decir, le tenemos que pasar el nombre del fichero y tantas parejas parámetro->valor como deseemos; en nuestro caso hemos especificado que queremos mostrar 10 frames por segundo y que no queremos compresión alguna en nuestro vídeo resultante.

Paso 2

Añadimos todos los frames que deseemos, para ello antes debemos convertir la imagen que queremos que aparezca en el vídeo en un frame; en definitiva:

frame = im2frame(image, gray(256));
movie = addframe(movie, frame);

Si tienes dudas sobre lo que hacen estas funciones puedes consultar las especificaciones de im2frame y de addframe.

Paso 3

Cerramos las variables y, por consiguiente dejamos el video listo para reproducirse en programas como el videolán:

movie = close(movie);

Recientemente adquirí un MacBook Pro 13″, tras 4 meses de uso, puedo decir con tranquilidad que es una maravilla de equipo; pero como todo cambio de sistema operativo, programas, equipo,… implica una serie de cambios a los que debemos acostumbrarnos poco a poco.

En este caso voy a comentar una solución al problema (o característica, según se vea) que nos impide seleccionar la url en Google Chrome al pulsar la techa F6 (o fn+F6) y al que nos permite refrescar/actualizar la página pulsando la tecla F5 (o fn+F5).

Realmente configurarlo para añadir esta característica es muy sencillo; para ello nos vamos a las preferencias del sistema>teclado; una vez ahí nos dirigimos a la pestaña “Atajos del teclado” ya que vamos a añadir 2. Antes de seguir con la configuración vamos a apuntar dos nombres de comandos tal y como aparecen en el menú de Chrome y que vamos a necesitar a la hora de definir nuestro atajo:

En el menú File (Archivo) del Chrome vemos que el comando que se corresponde con la techa ⌘L (Seleccionar la dirección)  es “Open Location…” en mi caso; esto debería hacer que al pulsar la combinación ⌘L, la URL se seleccione automáticamente (obtenga el foco); pues bien, nos apuntamos el nombre del comando “Open Location…” ya que lo necesitaremos más adelante.

Hacemos lo mismo pero con el comando ⌘R que está bajo el menú View (Ver), solo que en este caso con “Reload This Page“.

Como podemos ver, se han cambiado las teclas con las que se invocan dichas características del navegador, así que vamos a crear unos atajos de teclado, pero solo para esta aplicación; para ello nos vamos a la pestaña de las preferencias de teclado que hemos comentado antes y hacemos click en “Application Shortcuts” y acto seguido en el botón con un símbolo “+” y rellenamos dos veces el formulario con los datos obtenidos anteriormente, con lo que debería quedarnos como lo siguiente para recargar la página:

Y para la tecla F6:

De este modo, si volvemos al Chrome, veremos que la leyenda para los atajos de estos dos comandos ha cambiado a los nuevos valores.

y

Hace unas semanas publicamos una lista con 10 aplicaciones gratuitas recomendadas para iPad, pues bien, como es lógico, con el tiempo se van descubriendo nuevas aplicaciones que le darán una especial vidilla a nuestro nuevo equipo táctil.

10 de las aplicaciones de este artículo siguen siendo las del anterior, por lo que no vamos a volver a nombrarlas y describirlas, pero puedes verlas fácilmente dirigiéndote a dicho artículo.

Como dice el título del artículo, vamos a hablar de las 10 aplicaciones que nos faltan de una forma un poco más exhaustiva. Algunas de las aplicaciones que se describirán requerirán un proceso especial de instalación o bien, para poder disfrutarla al 100% habrá que hacerse con la versión de pago; pero si están aquí, es que ya merecen la pena sin haber pagado un duro.

Y sin más dilación, comencemos:

FeedlerRss: Una de mis herramientas favoritas de Internet y que relativamente poca gente usa o que ni siquiera sabe que existe, son los lectores de RSS. Esta herramientas, para los no enterados del tema, nos permite leer todas las actualizaciones de nuestras páginas favoritas, siempre y cuando den soporte a este sistema. Este tipo de lectores existen desde hace varios años, tanto como programas de escritorio o como otra página web que nos muestra el contenido de las demás; algunos ejemplos son: Google Reader, Netvibes, o el que estoy haciendo y pretendo publicar dentro de relativamente poco tiempo. Pues bien, en caso de que tengamos una cuenta de Google Reader, podremos vincular ésta con la aplicación Feedler, de manera que podremos leer cómodamente nuestro feed RSS desde nuestro iPad sin contar con las limitaciones de las aplicaciones web para dispositivos móviles. Como única pega, diría que abusa de las animaciones por todas partes.

Google: No, no nos referimos al buscador, al menos no en su totalidad, y es que Google ha desarrollado una aplicación para iPad que nos permite estar en todo momento siendo notificados de lo que sucede en los servicios que estos nos proporcionan. Realmente, la aplicación no hace nada revolucionario, simplemente es una aplicación que nos permite acceder a las páginas web y servicios de Google de forma rápida y nos notifica las novedades mediante el sistema de notificaciones estándar del sistema operativo del iPad.

iHeartRadio: ¿Sabes inglés?, ¿Te gusta escuchar la radio?, ¿Te gusta el carácter de Estados Unidos? Si la respuesta a alaguna de estas preguntas es SI, deberias plantearte seriamente hacer uso de esta aplicación, y es que iHeartRadio, es una aplicación en la que podremos encontrar una gran cantidad de radios estadounidenses fácilmente y hacer Streaming de ellas haciendo uso de nuestra conexión a Internet. El único gran problema de esta aplicación es que sólo está disponible en la App Store de Estados Unidos, por lo que o cambiamos las características de nuestra cuenta, o bien nos creamos otra de aquella zona para poder instalarla en nuestro iPad extranjero. Por desgracia tine una desventaja más, y es que la interfaz que usa es la de iPod/iPhone, pero como nos interesa utilizarla para escuchar emisoras, no creo que suponga un gran problema.

Buscar: Sí, el nombre es bastante poco explicativo en sí, pero es una aplicación bastante simple que nos permitirá, en caso de que perdamos alguno de nuestros dispositivos de la “manzana“, localizar iPod, iPhone, iPad,… que estén dados de alta en el servicio MobileMe, de manera que no tendremos que hacer uso de la página web que nos proporciona el mismo servicio y que desde dispositivos portátiles puede resultar un poco incómoda de utilizar.

PS Express: De acuerdo, estamos usando un iPad, manejar fotos puede no ser nuestra prioridad en este tipo de sistemas, pero teniendo en cuenta que la segunda versión del aparatito trae uncorporadas un par de cámaras de foto/vídeo, es posible que esto tome algo más de sentido, de hecho, la cámara de iPad 2 no es ni por asomo tan buena como la cámara de iPhone 4, es más, las fotos nocturnas dejan bastante que desear: salen con demasiado ruido (cosas de no poder jugar con el ISO, al menos que yo sepa). Entonces, pongámonos en situación, y es que queremos subir una foto a Facebook, Twitter, lo que sea, pero no sin antes eliminarle el ruido, desenfocarla un poco,… lo que sea. Para cosas rápidas como estas existe esta aplicación que, además, cuenta con una interfaz muy simple y amigable.

Bloomberg: La aplicación de la bolsa con la que viene el iPod/iPhone, si bien no es ninguna maravilla, es muy interesante para todos aquellos que cuenten con acciones y tengan cierta predisposición a saber el estado de la cotización en cada momento del día. Así que al poco tiempo de empezar a juguetear con el me entraron las ganas de encontrar una aplicación de estas características para iPad. Pues bien, Bloomberg, es esta aplicación.

SoundHound: Si eres de los que, como a mí, le encanta la música pero se cansa rápido de las canciones, SoundHound es la aplicación que necesitas, con esta podrás buscar canciones y descubrir música nueva de una forma rápida y dentro de un repertorio enorme.

Fring: Fring se está conviritiéndo en una seria alternativa a Skype en lo que a terminales móviles se refiere, ya que nos permite llamar a otros miembros mediante un sistema de VoIP, hacer conferencias múltiples, chatear o incluso llamar a números fijos con un pequeño sobrecargo. La ventaja de este sistema, es que nos permite hacer uso de la multiconferencia en el iPad y otros dispositivos, cosa que aun no podemos hacer con el Skype, aunque presumiblemente pronto podremos. Además, la aplicación, permite la sincronización con redes sociales y chats como Google Talk o Twitter.

TuneIn Radio: Como ya os he comentado anteriormente, me encanta escuchar la radio, y como ningún programa es perfecto para hacer esto, también tengo instalada en mi iPad, la aplicación TuneIn Radio, que complementa muy bien a la aplicación iHeartRadio con emisoras de todo el mundo.

Prezi Viewer: Prezi es un servicio web que nos permite hacer presentaciones para nuestras charlas enfocando el modo de hacerlo con un concepto totalmente diferente, es más, yo diría rompedor, y es que no se enfoca en el uso de diapositivas, sino que utiliza un único lienzo, desplazando la pantalla sobre él. Pues bien, Prezi Viewer nos permitirá ver estas presentaciones en nuestro iPad. Os recomiendo este servicio si queréis captar rápidamente la atención del público.

En los últimos artículos sobre las Macros en C/C++ hemos explicado de una forma un tanto rápida todo el potencial que presenta esta herramienta si sabemos utilizarla con un nivel medio-alto en determinadas situaciones.

Uno de los problemas que se nos presentan en ocasiones a la hora de trabajar en un lenguaje como C es que, a pesar de que contamos con depuradores de código, no siempre tenemos uno a mano, por lo que si a la vez que documentamos podemos mostrar a nuestro capricho y en función de la situación un log de lo que está sucediendo durante su ejecución, podremos hacernos una idea bastante aproximada de si todo va bien o no.

Tras esta pequeña reflexión me lanzo a compartir con vosotros un pequeño fichero .h que nos facilitará enormemente la tarea en una 20 líneas y que he utilizado ya en el desarrollo de varios programas:

#include <stdio.h>
//#define DEBUG 0
#define DEBUG 1
#ifndef __LOG_H
#define __LOG_H
 #if DEBUG == 1
 #define log(format, args...) \
		fprintf (stderr, "%s - %i: ", __FILE__, __LINE__);\
		fprintf (stderr, format "\n", ##args);
 #define warning(format, args...) \
			log("/!\\ "format" /!\\", ##args)
#define error(format, args...) \
		log("(X) "format" (X)", ##args)
 #else
#define log(format, args...) ;
#define warning(format, args...) ;
#define error(format, args...) ;
 #endif
#endif

Este fichero tendremos que incluirlo en nuestro programa escrito en C mediante una directiva #include:

#include "log.h"

en este caso he llamado al fichero que contiene esas 20 líneas de código.

De manera que si tenemos declarado DEBUG con un valor de 0 no se mostrará salida alguna y no sólo eso, sino que las líneas desaparecerán (es un claro ejemplo de uso de macros, ya que en nuestro programa en producción puede que deseemos tener más velocidad de procesado y no nos interese interactuar con salidas ni llamar a funciones que no hagan nada), mientras que si tiene un valor de 1, escupirá toda la información que deseemos por, en este caso, la salida de error de nuestro programa.

Si ejecutamos el siguiente programa en C:

#include "log.h"
int main(int argc, char** argv){

log("asdf%i", 1)

log("asdf")

warning("esto es una alerta")

warning("esto es una alerta%i", 1)

error("esto es un error")

error("esto es un error%i", 1)

}

obtendremos la siguiente salida:

bottle.c – 4: asdf1

bottle.c – 5: asdf

bottle.c – 6: /!\ esto es una alerta /!\

bottle.c – 7: /!\ esto es una alerta1 /!\

bottle.c – 8: (X) esto es un error (X)

bottle.c – 9: (X) esto es un error1 (X)

La ausencia de puntos y coma después de llamar las macros no es un error, es que simplemente no hacen falta.

Finalmente y a modo aclaratorio, las constantes utilizadas en el fichero log.h __FILE__ y __LINE__ son dos directivas de preprocesador que nos indican en qué lína y fichero de código tenemos la llamada a ese log.

Ayer, día 22 de junio del 2011, tuvo lugar una concentración de unas 1.000 personas en el palacio de congresos de Gerona con el fin de presentar en un único lugar a más de 500 jóvenes emprendedores o con ganas de serlo con otros tantos personajes ilustres del mundo de la empresa. El fin no es otro sino intentar apoyar a los más jóvenes a hacer realidad sus sueños y, quien sabe, quizá acudir al fórum como senior dentro de unos años.

Yo he sido uno de los privilegiados que, sin tener ninguna patente en curso, una empresa/idea medio montada,… ha tenido la oportunidad de asistir a tan magnífico evento, en el que no sólo hemos aprendido, sino que he hemos conocido a gente con las mismas inquietudes y con las que puede que, en un futuro no muy lejano, se pueda contar para intentar montar algo un poquito más grande que a lo que haríamos en condiciones normales.

Pero empecemos desde el principio…

Día 21

La llegada a Gerona, tras coger un AVE y un larga distancia, se produjo el día 21 de junio a eso de las 14h. Tras dar un paseo y comer algo, dio comienzo un taller de creatividad de jóvenes. Allí ademas de tener el primer contacto con nuestros compañeros, hicimos una serie de ejercicios que siempre tenían una moraleja (una de las que más me llamó la atención es la de descartar el primer 50% de las soluciones/respuestas a un problema, siempre y cuando, claro está, queramos ser creativos).

Una vez acabado el taller, tocó ir a cenar y después una charla/presentación de un par de horas con un primer grupo de personas muy interesante que nos conocimos durante la cena.

Día 22

Llegó el día complicado, bueno, complicado no, pero largo sí. A primera hora de la mañana tocaba estar en el palacio de congresos a la espera de aprender y conocer a tanta gente como fuese posible.

Primera sorpresa, el Fórum empieza muy fuerte; tras la breve introducción del Príncipe entra en escena Wendy Kopp (CEO de Tech for America) que nos deja frases e imágenes impresionantes grabadas en la cabeza tales como:

The world needs you before you get experience

Wendy Kopp

Un comienzo que viene seguido por la presentación de Mangus Scheving, que no se corta y entra haciendo el pino para después hacerse unas cuantas flexiones (es lo que tiene que hacer un superhéroe que ama la fruta), y nos enseña que con un buen método todo se puede conseguir, incluso aumentar las ventas de frutas con una serie (sportacus).

A todo esto, se hace un trabajo de ilustración de las ideas que se plantean en vivo…

Llegado a este punto los dos ponentes han dejado el listón muy alto, las siguientes exposiciones no dejan nada que desear, pero no nos dejan con la boca abierta de nuevo, al menos en lo que a la puesta en escena se refiere; aun así, no dejan de proponerse ideas que DE VERDAD podrían cambiar el mundo.

Otra de las ponencias que me dejaron con la boca abierta es la de Jon Dudas, presidente de FIRST; exposición en la que nos enseña lo que sale en las películas estadounidenses: estudiantes de instituto construyendo robots que resuelven problemas reales.

Otra de los proyectos que llaman la atención enormemente al anfiteatro es la de Félix Finkbeiner, un chico alemán que plantea plantar un billón (trillón americano) de árboles en los próximos años mediante una ONG; pero no es tan sorprendente la idea, como el hecho de que la lidera un chaval con tan sólo 13 años.

Después de una estupenda comida, se retoman las conferencias, pero para combatir el sopor postprandial, en la jornada de tarde disfrutamos de la música de un grupo de Jazz y de un par de representaciones teatrales cortas, mientras Tariq Krim, InmaShara,… nos exponen de una forma más o menos idealista las sus ideas. Finalmente y acabando con las presentaciones, David Berry nos plantea sus ideas para cambiar el mundo,… realmente impresionante la presentación.

Para terminar el Fórum Impulsa 2011 se procede a un breve resumen de la jornada y a la entrega de los premios IMPULSA 2011.

Sinceramente una experiencia impresionante y deseando repetirla el año que viene, si me invitan de nuevo, claro.

No sé si algún asistente al Fórum  leerá esto, pero en caso de hacerlo y no haberse incorporado al grupo de Facebook “Forum Impulsa 2011″, le animo a que se una.

Como último artículo de la serie, vamos a adentrarnos un poco más en la declaración de elementos similares a las funciones con macros , para ser más exactos, con sus argumentos y posibilidades:

Convertir a String

En ocasiones no es de un gran interés tratar de la misma manera todos los argumentos que le pasamos a este tipo de funciones de preprocesador.

En el caso concreto de que deseemos tratar el argumento como un String constante, habremos de precederlo con el símbolo ‘#‘, demnaera que estamos convirtiendo en constantes dichos parámetros, pero veamos un ejemplo que he sacado de gnu.org, ya que me parece bastante ilustrativo.

#define WARN_IF(EXP) \
     do { if (EXP) \
             fprintf (stderr, "Warning: " #EXP "\n"); } \
     while (0)
     WARN_IF (x == 0);

Este pedazo de código nos dará una salida como la siguiente:

do { if (x == 0) fprintf (stderr, “Warning: ” “x == 0″ “\n”); } while (0);

Es decir, el argumento EXP se sustituye como argumento en el primer caso y como un string en el segundo.

Una de las grandes ventajas de la conversión a String de este tipo de macros, es que no sólo añade dobles comillas, sino que escapa los caracteres necesarios para que la cadena se muestre tal y como es, a no ser que esta se encuentre dentro de una cadena de texto ya o sea un carácter como ‘\n‘.

Finalmente puede resultarnos de utilidad concatenar un par de tokens dados dentro de una macro; para ello podremos hacer uso de ‘##‘

Parámetros indefinidos

Algo que puede resultarnos muy interesante e incluso increíble cuando empezamos a utilizar C, es que, si bien nos han enseñado a que las funciones tienen un número definido de parámetros, ¿cómo es posible la existencia de funciones como printf?

Al igual que para las funciones, existe una forma de hacer que una macro acepte un número no definido de parámetros, y este método aparece en forma de __VA_ARGS__. Este token nos permitirá sustotuir en nuestro macro los ‘…‘ por los valores que se le han pasado a la función.

#define log(...) printf(__VA_ARGS__)

Si queremos ser más descriptivos con los parámetros podemos sustituir ‘…‘ por ‘<nombre>…‘, por ejemplo:

#define log(args...) printf(args)

Si queremos especificar un número mínimo de argumentos, podemos hacerlo de la siguiente manera:

#define log(formato, args...) printf(formato, args)

pero esto hace que sea obligatorio, en todo momento, si no pasar un segundo argumento, sí escribir la coma después del primero. Para solucionar este problema, de nuevo acudimos al manual de gnu.org que nos dice que echemos mano de ‘##‘, de manera que podamos omitir, si lo deseamos el segundo parámetro y la coma de después del primero al llamar a la macro:

#define log(formato, args...) printf(formato, ##args)

En el pasado y primer artículo de esta serie, describimos a grosso modo el funcionamiento de la directiva de preprocesador #define; siendo una de las características más importantes a tener en cuenta el hecho de que a la hora de compilar el programa no estamos trabajando con variables con un valor, sino con los valores directamente. De este modo estaremos ahorrando memoria y dotando de legibilidad a nuestro código en determinadas ocasiones.

Hoy vamos a ver cómo simular funciones con el sistema de Macros. Antes de nada, hay que aclarar que: si bien para constantes, por convenio, se utilizan letras mayúsculas en todo momento, para esta especie de funciones no es necesario hacer esto, de manera que podemos continuar con el sistema de nomenclaturas que hemos estado llevando hasta el momento (como recomendación, yo usaría todo en minúsculas menos la primera letra de cada palabra exceptuando la de la primera, Ex: hallarMaximo(…)).

Supongamos que contamos con dos funciones en nuestras librerías:

int rand(void);
int fastRand(void);

Ambas funciones llevan a cabo la misma tarea, sólo que utilizan diferentes métodos para realizarla, de hecho, la segunda que es mucho más eficiente que la primera (como puede entenderse por el nombre), la acabamos de implementar y, a pesar de que la entrada y la salida es la misma, la primera ha sido utilizada cientos de veces en nuestro código, y cambiarla implicaría un repaso exhaustivo del código fuente y, en caso de tener una API pública, implicaría cambiarla y notificárselo a todos nuestros usuarios.

En lugar de esto, podemos crear una macro que se encargue de realizar dicha sustitución durante el proceso de precompilado:

#define rand() fastRand()

de manera que, cada vez que llamemos a la función rand() en nuestro código, a la hora de compilarlo, es como si estuviésemos llamando a la función fastRand().

Pero el poder de esta herramienta no se para con estas características, sino que nos permite definir algo parecido a funciones de forma completa. Con esto quiero decir que podemos definir macros que a la hora de editar el código y utilizarlos, podemos asumir que son funciones. Pongamos un ejemplo:

#define max(x, y) ((x > y) ? x : y)

una vez hehcha esta definición, nosotros, desde nuestro código podremos llamar a esta “función” evitando que se gasten, entre otras cosas niveles de pila, ya que el código es sustituido durante el proceso de preprocesado, de manera que si escribimos en nuestro código:

int a = 2;
int b = 4;
int z = max(a, b);

el código que realmente se estará ejecutando una vez compilado será:

int a = 2;
int b = 4;
int z = ((a > b) ? a : b);

Uno de los grandes problemas de utilizar esta técnica para sustituir a las funciones es que, como podemos observar es que, a la hora de llamar a la macro, no tenemos comprobación del tipado de los datos que le pasamos, pudiendo obtener así, resultados inesperados o incluso errores de estabilidad del programa. Hay que ser conscientes en todo momento de que los argumentos, a la hora de llamar a una macro que se comporta por una función, estarán separados por comas.

Finalmente, a la hora de llamar a una macro, si no le pasamos el número de argumentos necesarios, obtendremos un error de preprocesador, pero en caso de que le pasemos argumentos vacíos, estos se sustiuirán por argumentos vacíos sin dar error durante el proceso de preprocesado.



Recientemente adquirí un iPad 2 porque deseaba meterme en el mundillo de la programación para este tipo de dispositivos, y dado que no es lo mismo probarlos sobre una pantalla de ordenador que sobre el cacharro en si (esto es algo que he aprendido de haberme introducido en el mundo de programación de aplicaciones móviles para el sistema operativo Android), decidí lanzarme a la piscina con ello.

El caso es que llevo dos días dándole un uso mas que aceptable al iPad, y tras ello me gustaría comentarles una serie de aplicaciones gratuitas que, a mi modo de ver, le convendría tenerla instalada si posee uno de estos cacharrilos.

Ante la gran cantidad de artículos de este tipo, me gustaría darle un nuevo enfoque a este post. No solo vamos a comentar las aplicaciones sino que vamos a comentarlas desde un punto mas técnico y no contando solo sus bondades, sino también sus debilidades; además, vamos a comentar las que a mi, como informático y teleco que soy ademas de bloguero, webmaster,… Me parecen interesantes desde este punto de vista…

• Dropbox: en poco menos de un año, Dopbox se ha convertido en una de las aplicaciones imprescindibles en todos mis dispositivos, tanto móviles como no. Gracias a esta aplicación, y contando in una conexión a internet seremos capaces de acceder a nuestros ficheros en cualquier parte del mundo y equipo, llegando incluso a ofrecernos un sistema de versionado de los ficheros durante el ultimo mes. Si aun no tienes cuenta y deseas creaste una, puedes hacer click en el siguiente enlace:http://www.dropbox.com/referrals/NTkyNTM4MTk5. Ya que si en lugar de utilizar el de la pagina principal del servicio, utiliza este, obtendrá un bonos de 250MB extra totalmente gratis.
• iCromy: es un navegador recién salido del horno que nos permitirá navegar desde nuestro tablet sin tener que recurrir a pulsar varios botones para poder navegar entre las diferentes pestañas que nos interesen. Además seremos capaces de marcar paginas como favoritas y como pendientes de lectura, esta ultima funcionalidad me ha parecido de gran interés. Finalmente y como contra he de mencionar que, entre otras mejoras, deberían habilitar el teclado especial para introducir direcciones web en la barra de navegación.
• Twitter: como no, no podíamos ser menos, y es que si para android e iPhone utilizo tweetDeck, he de reconocer que, el hecho de que no este adaptada la resolución para el iPad, lo hace incomodo de utilizar, de manera que lo mas sensato es hacer uso de la aplicación oficial, ya que nos permitirá navegar sin problemas por todas las opciones que nos proporciona la red social.
• MyPad: Facebook es una red social que no ha desarrollado una aplicación oficial para navegar porque su red social, lo cual dificulta enormemente el uso de la red social, o bien nos obliga a utilizar la de iPhone, lo que nos obliga a conformarnos con una mala resolución. Pues bien, ante la tardanza de la aparición de aplicaciones oficiales, ha nacido MyPad, una aplicación que nos hará poder navegar por nuestro perfil sin ningún tipo de problema?
• WordPress: si eres dueño, editor,… De un blog WordPress, esta aplicación no puede faltar en tu iPad, mediante esta aplicación podremos desde moderar comentarios hasta crear paginas pasando por la escritura de nuevos artículos sin tener que encender nuestro ordenador.
• Skype: a pesar de ser una aplicación diseñada para el iPhone e iPod touch, y por consiguiente la resolución de la aplicación es paupérrima, no nos queda más remedio que usarla si deseamos poder utilizar esta magnífica herramienta de comunicación. Como contras nos encontramos con que con el iPad viene instalada una aplicación muy similar llamada FaceTime y que, además no cuenta con compatibilidad para videollamadas.
• uPad lite: esta es para mi gusto la mejor aplicación para la toma de notas sobre el iPad con la que contamos en el Apple store de forma gratuita, ya que nos permite hacer zoom de zonas, establecer un área de apoyo para la mano,… Sinceramente, he de decir que es una auténtica maravilla, ya os comentaré como va la versión PRO si al final decido compraría, algo muy probable, sinceramente.
• TeamViewer: como ya he dicho me dedico profesional y educacionalmente al mundo de las nuevas tecnologías, y no es raro que un amigo, familiar, o simplemente yo mismo, requiera que modifique algo en su ordenador remotamente, pues bien, si utilizamos esta aplicación, seremos capaces de controlar dichos ordenadores sin pagar un céntimo siempre y cuando su uso sea de carácter personal y no comercial.
• Google earth: una gran aplicación que deja pequeña a la aplicación maps y que que, en parte nos muestra las capacidades de renderizado de nuestro iPad, ademas es un interesante programa con el cual viajar sin gastarnos un céntimo, descubrir nuevos lugares o, simplemente planificar nuestras próximas vacaciones familiares o con los amigos.
• Tap to Chat: la verdad es que no tenía intención de poner este tipo de aplicaciones aquí, pero la forma de presentar las conversaciones del chat de gmail por este programa me ha dejado gratamente sorprendido, definitivamente muy recomendable si utilizamos con asiduidad el chat que nos ofrece Google desde su plataforma de correo electrónico.

Como habrán podido observar, la lista se asemeja a otras en parte, pero no en su totalidad, y aunque estoy seguro de que me dejo grandes programas en el tintero, como por ejemplo Evernote, he decidido no meternos en mi top 10, ya que para suplir esa necesidad ya utilizo otras aplicaciones web desde hace tiempo, como por ejemplo, la ya comentada en este blog Diary.

Si tienen alguna recomendación o queréis que pruebe y luego comente alguna aplicación, sienta se libres de dejar un comentario en esta entrada.

Todo programador de C y C++ que se precie debe estar más o menos familiarizado con las directivas de preprocesador en general y mas concretamente, debería estarlo con las llamadas Macros. Una macro es un trozo de código, usualmente en la zona de cabecera o en los propios ficheros de cabecera (*.h).

Las macros se definen mediante la directiva #define; veamos un ejemplo:

#define PI 3.14159

Esta macro se encarga de asociar el valor 3.14159 con el valor PI mediante la directiva #define, es decir, la estructura sería algo así como lo siguiente:

#define <alias> <valor>

dónde <alias> es el nombre que queremos utilizar para referirnos al término que ocuparía el lugar de <valor>. Ésta característica de C se utiliza sobre todo para facilitar el uso de variables que durante todo el programa van a tener el mismo valor, ya sea por el hecho de que son constantes, como por ejemplo el valor del número pi (3.14159), el valor de la gravedad terrestre g (9.81) o cualquier otra constante o porque simplmente son eso, constantes que no variarán, como por ejemplo el tamaño máximo de un array.

Un aspecto relativamente importante de las macros es que, por convenio, y para facilitar la lectura de las mismas en programas, se suelen utilizar letras mayúsclas, de manera que si nos encontramos con:

int main(int argc, char** argv){

printf("%f, %f", r, PI);

return 0;

}

podríamos concluir que la letra r se corresponde con una variable, ya que está está (o empieza) con minúsculas, mientras que PI es un valor constante. Ambos valores han de estar definidos con anterioridad.

Veamos un ejemplo práctico de uso:

#include <stdio.h>

#define PI 3.14159

int main(int argc, char** argv){

double radio = 25.684;

double area = PI * radio * radio;

return 0;

}

La directiva #define no sólo nos servirá para definir valores de variables, sino que también podremos utilizarlo para declarar valores de arrays:

#define CONTENIDO 0, \
                     1, \
                     2
int main(int argc, char** argv){
int valores[] = { CONTENIDO };
return 0;
}

Como habréis podido comprobar detrás de las dos primeras líneas de código aparece una barra inclinada (\), esto quiere decir que la declaración de la macro va a continuar en la línea siguiente, lo cual nos facilitará enormemente la legibilidad de nuestro código.

¿Por qué nos convendría usar macros?

El uso de macros puede parecer un poco absurdo de buenas a primeras, ya que podemos utilizar funciones (ya veremos más adelante el porqué de esta afirmación) o variables para conseguir los mismos resultados. La diferencia entre usar unas u otras es que al usar macros, el código del <alias> se sustituye por el del <valor> durante el proceso de pre-compilación, de manera que a la hora de compilarlo, el código queda sustituido y al ejecutarlo no tendremos que malgastar ciclos de CPU realizando cálculos como este.

¿Podemos invalidar algo declarado con un #define?

Efectivamente podemos hacerlo mediante el uso de la directiva de preprocesador:

#undef <alias>

http://diary.dipler.org

Seguimos con el desarrollo de la modesta aplicación que nos permite llevar un diario mientras nos facilita la vida para llevar un listado de tareas e ideas de forma completamente privada, y es que después de un tiempo sin actualizaciones oficiales, me complace presentar Diary 2.3, esta versión viene con las siguientes novedades que, espero les parezcan interesantes:

• Corrección de errores puntuales en la edición de entradas categorizadas con un flag distinto al de Diario.
• Corregido el error al pulsar el botón more después de haber realizado una búsqueda.
• Corregido el error al codificar los signos +.
• Mejora de los estilos para mejorar su compatibilidad con Firefox 4 e Internet Explorer 9.
• Añadida la función de crecimiento automático del area de texto en función del contenido para mensajes nuevos.
• Añadida la función de crecimiento automático del area de texto en función del contenido para el modo de edición de mensajes.
• Añadidos hastags al estilo de los tags de Twitter, en los que al pulsar en ellos se realiza automáticamente una búsqueda con dchos tags.
• Por defecto cuando llegamos a la parte final de la lista de elementos cargados, s

http://diary.dipler.org

.NET es un lenguaje de programación para equipos Windows que también nos es de gran utilidad a la hora de hacer completas aplicaciones web que necesitan un plano de controlador potente. Por el contrario nos dificulta algunas tareas como las de maquetar el HTML. Me explico: en PHP, cuando ejecutamos un script este siempre genera el código HTML que ha de mostrarse desde 0 a cambio de tener que trabajarnos un poco más el sistema de control de los datos de las páginas usando, por ejemplo, sistemas como el de las sesiones, es decir, tenemos que hacerlo todo “a mano”.

Por el contrario .NET nos ofrece trabajar con los llamados “PostBack”, este sistema de “refresco” de las páginas convierten un sistema sin estado, como son las conexiones HTTP, es una especie de sistema con estado mediante el uso de estructuras como el ViewState.

Esta especie de sistema de conexión con estado hace que, en caso de querer generar HTML de forma dinámica sin plantillas previas, nuestro trabajo pueda convertirse en una ardua tarea.

Para ello podemos hacer uso de una función llamada Page_init ( en lugar o además de Page_load). En esta función, si bien no tiene acceso a estructuras de datos como por ejemplo el ViewState, podemos pintar en el documento un layout HTML a mano antes de que el flujo de la página siga su transcurso, incluso antes de que se cargue el ViewState. Hasta aquí todo normal, y probablemente no le suponga ninguna novedad, peqro ¿Qué pasa cuando hay un PostBack en la pagina que hemos generado de forma dinámica?

Respuesta: si dentro de Page_init no hacemos uso de el condicional !Page.isPostBack, es decir, no ponemos nuestro códig de generación de HTML dentro de un if con esa condición, el código HTML, además de generarse de nuevo, en caso de ser un formulario o algo parecido, este mantendrá los datos introducidos en el mismo antes de hacer dicho PostBack.

El zip bomba o zip de la muerte es un fichero *.zip de pequeño tamaño que al descomprimirse genera ficheros que, almacenados en disco, pueden llegar a ocupar una salvajada de espacio en disco. La finalidad de este tipo de ficheros es dejar inutilizado, bloquear un equipo durante un periodo de tiempo o mantener entretenido a programas antivirus.

Un ejemplo de este tipo de ficheros es el llamado 42.zip, el cual es un fichero de 42.374 bytes que almacena en suinterior otros 16 ficheros zip que contienen el mismo número de ficheros. Si repetimos este proceso 6 veces, obtendremos como resultado esta maravillosa arma de destrucción de ordenadores (entiendase la ironía). Finalmente, cada fichero final contiene un fichero de 4,3 GB, es decir, que si hacemos unos pequeños cálculos…

Para crear uno de estos ficheros no tenemos que crear complejos algoritmos ni nada por el estilo, sino que nos bastará con crear un fichero de texto y llenarlo con valores null hasta que lleguemos al tamaño de fichero deseado, una vez comprimido el fichero se comprimirá con un ratio muy grande, de manera que somos capaces de meter tanta información en un espacio tan pequeño como 42kB.

Pero, ¿cómo funciona?, los servidores que se encargan de controlar que a una determinada red no entran ficheros malintencionados se ven obligados a descomprimir determinados ficheros comprimidos no cifrados de forma automática, de tal manera que si tiene que descomprimir un fichero que, una vez descomprimido llega a ocupar 4,5 PB deja el servidor completamente inutilizado, no sólo por el espacio en disco que ocupa el fichero descomprimido, sino que también puede quedar colapsado por el número de ciclos de CPU utilizados.

Dipler no es una página que nació tal y como la conocéis hoy, de hecho la que es hoy Dipler nació bajo el nombre de Bit’n'Byte y poco a poco fui adquiriendo los dominios de dipler.org y dipler.com y esto, ¿por qué?, se preguntarán. Hace ya cuatro años fundé con unos amigos una página web en formato de blog de contenidos generales llamada Dipler, esta página, si bien no consiguió llegar a tener un gran número de visitas diarias (los mejores días no llegaba a 100 usuarios), en relativamente poco tiempo consiguió un hito nada fácil de conseguir llegar a la portada de Menéame con un artículo escrito por Jaime Ochoa:

Esto nos propició en menos de un día, concretamente en unas pocas horas, la friolera de más de 3.000 visitantes únicos, lo cual para mi y para mis compañeros editores nos pareció una auténtica barbaridad. Esperábamos que de todas esas visitas al menos un porcentaje se viese atraído por el contenido de la página y que siguiesen visitándonos, desafortunadamente eso no pasó, al menos en la medida que nos esperábamos, cayendo las visitas de nuevo de forma abrupta a un punto similar al anterior, es decir, en un día aumentó en un 3.000% el número de visitas y al día siguiente cayó de nuevo a la normalidad.

Relativamente poco después de este suceso, desafortunadamente y por motivos de falta de tiempo de los componentes del equipo, la página original de Dipler murió y naciendo así, el 21 de julio de 2008, la página que hoy conocéis y cuyo principal editor soy yo. Esta página volvió a alcanzar los últimos puestos de la portada de menéame y de bitácoras alguna que otra vez, pero en ningún momento se volvió a repetir dicho efecto de una forma tan pronunciada hasta el pasado viernes 11 de febrero de 2011.

El día 11 de febrero a las 10 de la mañana, entré en el sistema de estadísticas de Google Analytics y me llevé una sorpresa al ver que el número de visitas del día ascendía a algo más de 2.000, sobre todo si tenemos en cuenta que el número medio de visitas de esta página web es de unos 300 usuarios al día.

Rápidamente se me vino a la cabeza el ya conocido por nosotros “Efecto Menéame“, pero para que eso sucediese tendría que estar, no solo en portada, sino en una de las primeras lineas de la página. Esto se me antojaba extraño, porque el último post que había publicado hasta esa fecha era Diary 0.2.1 (10/02/2011), el cual, ni mucho menos era propio de una portada de Menéame, ya que no era una noticia relevante, ni mucho menos  por muy útil que les parezca a algunos dicha utilidad. Así que decidí seguir investigando en Google Analytics para ver de dónde procedían las visitas (quizá debería haber hecho eso desde un principio, pero nadie es perfecto).

Tras ir al apartado de fuentes de tráfico vi que la inmensa mayoría de las visitas provenían referenciadas desde Google, lo cual se me antojaba aun más extraño que el hecho de que el artículo que contaba las últimas novedades en Diary 0.2.1 hubiese sido portada en Menéame. Tras indagar un poco más vi que las palabras claves de acceso a la página que estaban redireccionando a esta página esa ingente cantidad de tráfico  eran “Thomas Edison“.

O todo el mundo tiene que hacer un trabajo sobre Edison al mismo momento o, sinceramente, no se me ocurría qué podía estar sucediendo. A todo esto las visitas la casi llegaban a las 3.000. Minutos más tarde entro en Google y me encuentro con el siguiente Doodle:

¡Ya está! Esta era la respuesta que estaba buscando, se celebraba un evento relacionado con Edison y uno de los artículos de este blog aparecía bien posicionado bajo esas palabras clave, de hecho la imágen que encabezaba el artículo aparecía la primera de todas en Google Images.

Dado que los Doodles suelen estar online por un periodo de 24h o más (dado que México, venezuela,… son países en los que se habla también el español y hay una gran diferencia horaria), me planteé muy seriamente si mi humilde servidor compartido, que no es capaz de cumplir los requisitos de velocidad de algunos buscadores, sería capaz de atender todo el tráfico que se avecinaba sin caerse, sobre todo teniendo en cuenta que hay varias páginas alojadas en mi cuenta y supongo que lo mismo en las de los otros usuarios. Para minimizar el consumo y los tiempos de despachado de páginas, habilité rápidamente todos los sistemas de cacheado que tenía a mi disposición, ya que mil visitas por hora es una cifra bastante elevada para un hosting compartido. Tras esto me acordé del post “cómo aguantar una portada de Menéame” y me dispuse a cachear la página el sitios externos por si tenía que redirigir el tráfico desde la página principal.

Sorprendentemente el servidor aguantó estoicamente durante 36 horas aproximadamente y soportando de media unas 1.000 visitas por hora, llegando a alcanzar las 26.394 visitas el día 11 de febrero y 9.868 visitas el día 24 de febrero. Mi más sincera enhorabuena al personal de Dreamhost y de los desarrolladores del plugin super caché para WordPress.

De nuevo, ingénuo de mí, pensé que alguna de esas visitas se convertiría en asiduos a la página, pero de nuevo, esto sucedió de una forma muy leve. No obstante, es impresionante el poder de algunas páginas web véase, en este caso,  Google a la hora de redireccionar visitas de un lado para otro.

http://diary.dipler.org

Llevabamos ya un tiempo sin añadirle mejoras a la aplicación Diary, así que he creido oportuno lanzar una actualización en estas fechas. Si bien la actualización no tiene grandes mejoras abre paso a un nuevo ámbito de desarrollo. Para futuras versiones se pretende añadir notificaciones por email, planificar tareas para fechas seleccionadas y la integración de la aplicación con redes sociales como Facebook y/o Twitter.

En resúmen, las mejoras añadidas y los errores corregidos en esta versión son los siguientes:

• Mejorado el rendimiento interno de alguna de las funciones del núcleo de la aplicación.
• Se permite el borrado de entradas.
• Se permite la edición de entradas (en caso de ser una tarea, esta estará marcada como no terminada por defecto.
• Cambios leves en las estrucutras de datos que almacenan la información relativa a las entradas.
• Añadidos efectos de transiciones en la barra de notificaciones.
• Movida a la parte inferior la barra de notifiaciones.
• Corregido el error al introducir en una entrada la barra inclinada “\”.
• Si una tarea está finalizada se mostrará el borde de color verde.
• Mejorada la notificación de cargando.
• Leve cambio en la hoja de estilos en lo relevante a enlaces,…

Tal y como algunos de vosotros ya sabréis, la nueva versión de Ubuntu 11.04 Natty Narwhal realiza un cambio radical en lo que a interfaz de usuario se refiere, y es que pasaremos de utilizar el ya conocido por muchos entorno de escritorio llamado Gnome al no tan conocido Unity. Este sistema de gestión de escritorios ya está implementado en la versión actual 10.10 para netbooks.

Hasta este momento, las versiones alpha de este sistema operativo estaban bastante verdes, ya que, entre otras cosas, no funcionaba correctamente la combinación de teclas Alt+Tab,… pero recientemente se han realizado una serie de mejoras muy importantes, entre las que nos encontramos un buen funcionamiento de dicha combinación de teclas y otras mejoras en la experiencia del usuario a la hora de interactuar con el equipo.

Algunas de las grandes mejoras introducidas en esta versión de Ubuntu son:

Aumento del espacio de trabajo

Se elimina la barra de tareas inferior para integrarlo todo en el dock lateral, además de en la barra superior, lugar en el que aparecerá tanto el menú de la aplicación como la cabecera de la ventana que tiene el foco (esto último solo en caso de que la aplicación esté maximizada).

Selección de ventana

Además de poder cambiar presionando Alt+Tab, si tenemos la misma aplicación abierta varias veces, esta estará agrupada en el dock, y al hacer click sobre su correspondiente icono se nos mostrarán todas las ventanas en ejecución al más puro estilo OS X, de manera que podremos saber con facilidad cual de estas pantallas es la que deseamos traer al frente.

Posiciones predefinidas de ventana

Una de las novedades que más me gustaron de las que vinieron de la mano de Windows 7, si no la que más, es que en función de la posición del escritorio a la que arrastremos la ventana, esta se maximizará o tomará una forma determinada, de modo que nos evita tener que redimensionar manualmente las ventanas si, por ejemplo, deseamos tener dos medias ventanas activas.

Hace una semana comentábamos el modo de crear un ListView para Android con, como mínimo, un CheckBox en cada fila de la lista. Este mini tutorial de hoy, en el que vamos a explicar como marcar de una todos los CheckBox de un ListView, vamos a basarnos en el contenido explicado en dicho artículo.

En principio la metodología parece sencilla, en nuestro fichero main.xml, además de declarar un ListView, declaramos en la parte inferior un CheckBox cuyo comportamiento determinaremos más adelante, de manera que el contenido del main.xml quedaría de la siguiente manera:

main.xml

<?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">
    <ListView
    	android:id="@+id/list"
    	android:layout_width="fill_parent"
    	android:layout_height="wrap_content"
        android:layout_weight="1"
        android:drawSelectorOnTop="false"/>
	<CheckBox
		android:id="@+id/chkSelectAll"
		android:text="@string/chkSelectAll"
		android:visibility="visible"
		android:layout_width="fill_parent"
		android:layout_height="wrap_content"/>
</LinearLayout>

Hasta aquí todo ha sido coser y cantar, de nuevo hemos de definir un fichero con el Layout de cada una de las filas de lo que será nuestro ListView, en nuestro caso item.xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
	android:layout_height="wrap_content"
	android:layout_width="fill_parent">
	<CheckBox
		android:id="@+id/chkItem"
		android:visibility="visible"
		android:layout_width="fill_parent"
		android:layout_height="wrap_content"/>
</LinearLayout>

Una vez que tenemos hecho esto nos bastará con definir el comportamiento de la clase principal para que al marchar el chkSelectAll se marquen todos los CheckBox de la lista, para ello en un principio, con poner el array que determina el valor de cada CheckBox a true o false, en función del caso, debería sernos suficiente. Para ello añadiríamos en el onCreate las liguientes lineas:

        chkAll = (CheckBox)findViewById(R.id.chkSelectAll);
        chkAll.setOnCheckedChangeListener(new OnCheckedChangeListener(){
			@Override
			public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) {
				for (int i = 0; i < adapter.getItemsLength(); i++) {
    	                                adapter.set(i, b);
    	                        }
			}
        });

El problema nos lo encontramos cuando lo que queremos es que además de marcarlos en el sistema queremos que se visualicen los CheckBox marcados directamente, para ello, lo que podemos hacer (AVISO: es una solución un poco cutre y simplemente para salir del paso) es reasignar el adaptador, para lo que después del for podríamos añadir las siguientes lineas:

        int pos = list.getFirstVisiblePosition();
    	list.setAdapter(adapter);
    	list.setSelection(pos);

Si ahora compilamos y ejecutamos el código podremos observar como el comportamiento es el deseado.

Android es un gran sistema operativo para móviles que le supone una competencia directa al iOS, y por lo tanto meterse como programador en su mundo puede ser algo muy atractivo. Pero como programadores más o menos experimentados sabemos que no todo es un paseo, tal y como algunos pretenden plantearlo; siempre surgen problemas que habremos de solucionar. Hoy, vamos a ver como evitar que, al tener un ListView en el que cada fila contenga un CheckBox, al hacer scroll, los elementos de la parte no visible se marquen al marcar uno de la parte visible de manera automática.

¿Por qué?

Esto sucede porque Android reutiliza las mismas vistas una y otra vez a la hora de pintar los elementos en pantalla, de manera que aunque el CheckBox que ha de mostrar no está seleccionado, se mostrará como tal dado que uno visible anteriormente ya lo estaba. De este modo se ahorra una gran cantidad de ciclos de CPU a la hora de generar la imagen que se va a mostrar.

Cómo podemos ver, el comportamiento por defecto del sistema operativo no siempre nos viene bien ya que, en casos como este, puede dar lugar a confusiones en el usuario final de la aplicación.

Solución

La manera de solucionar este pequeño inconveniente, aunque no de la forma más óptima, es tan simple como establecer a mano el valor del CheckBox que ha de mostrarse en cada momento, para ello tendremos que apoyarnos en una serie de clases y ficheros XML.

Antes de nada, vamos a analizar los ficheros que componen nuestro Layout, es decir, el que establece la distribución de la pantalla principal y el que establece el aspecto de cada una de las filas.

main.xml

<?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">
<ListView
android:id="@+id/list"
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:layout_weight="1"
android:drawSelectorOnTop="false"/>
</LinearLayout>

row.xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_height="wrap_content"
android:layout_width="fill_parent">
<CheckBox
android:id="@+id/chkItem"
android:visibility="visible"
android:layout_width="fill_parent"
android:layout_height="wrap_content"/>
</LinearLayout>

Tal y como se puede observar, hasta este momento no hemos hecho más que definir dos layouts, uno que contiene un ListView y otro que contiene el CheckBox que ha de aparecer en cada fila.

Prosigamos programando nuestra clase Java para manejar estos Layouts:

package org.dipler.chkList;

import java.util.ArrayList;

import android.app.Activity;
import android.content.Context;
import android.database.Cursor;
import android.os.Bundle;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.BaseAdapter;
import android.widget.CheckBox;
import android.widget.CompoundButton;
import android.widget.ListView;
import android.widget.CompoundButton.OnCheckedChangeListener;

public class Main extends Activity {
private ChkListAdapter adapter;
private ListView list;
private CheckBox chkAll;

@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
list = (ListView)findViewById(R.id.list);
fillList();
}

private void fillList() {
int num = 50;
adapter = new ChkListAdapter(num);
for(int i = 0; i < num; i++){
adapter.addItem(new Item(String.valueOf(i), "item number " + i));
}
list.setAdapter(adapter);
}

private class ChkListAdapter extends BaseAdapter {
private ArrayList<Item> items = new ArrayList<Item>();
private LayoutInflater inflater;
private boolean[] itemSelection;
public ChkListAdapter(int size) {
inflater = (LayoutInflater)getSystemService(Context.LAYOUT_INFLATER_SERVICE);
this.itemSelection = new boolean[size];
}

public void addItem(final Item item) {
items.add(item);
notifyDataSetChanged();
}

@Override
public int getCount() {
return items.size();
}

@Override
public String getItem(int position) {
return items.get(position).toString();
}

@Override
public long getItemId(int position) {
return position;
}

@Override
public View getView(final int position, View convertView, ViewGroup parent) {
convertView = inflater.inflate(R.layout.row, null);
final ViewHolder holder = new ViewHolder();
holder.chkItem = (CheckBox)convertView.findViewById(R.id.chkItem);
holder.chkItem.setOnCheckedChangeListener(new OnCheckedChangeListener(){
@Override
public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) {
itemSelection[position] = holder.chkItem.isChecked();
}
});

holder.chkItem.setChecked(itemSelection[position]);
convertView.setTag(holder);
holder.chkItem.setText(getItem(position));
return convertView;
}

public int getItemsLength() {
if(itemSelection == null) return 0;
return itemSelection.length;
}

public void set(int i, boolean b) {
itemSelection[i] = b;
}

}

public static class ViewHolder {
public CheckBox chkItem;
}

}

Como podemos observar el la, bueno, las clases Java que hemos declarado tenemos:

• La clase Activity principal que utiliza el Layout main.xml y que en el método onCreate() rellena el ListView con elementos, en nuestro caso de tipo Item (Item es una clase cualquiera con dos atributos, un id y un texto)
• El adapter, que es la clase que se va a dedicar a repintar las filas tantas veces como sea necesario llamando al método getView() en cada una de esas ocasiones.
• La clase ViewHolder que nos facilita el trabajo con la clase Row, esta clase no es en sí necesaria, pero vi la idea en amberfog y me gustó, de hecho de esta misma página obtuve una visión mucho más clara del funcionamiento de estos artificios llamados “Views”

El procedimiento para evitar que se marquen solos los CheckBox que cumplen el periodo, es sencillo, llevamos un array de booleanos en el que establecemos el estado de cada elemento de la lista confome cambia el valor del CheckBox, de manera que cada vez quedeseemos mostrar dicho elemento, el método getView(), en lugar de pintar como cree que debería pintar estos CheckBox, los muestra marcados o desmarcados en función del array que hemos creado y que vamos actualizando dinámicamente.

El método propuesto no es el más eficiente que nos podamos encontrar, pero funciona y nos puede ayudar a salir del paso.

http://diary.dipler.org

Como ya sabréis, las versiones de Diary 0.2.x están girando en torno a los diferentes tipos de entradas que podemos tener, así como en una mejora del rendimiento y de la seguridad que presenta la aplicación para permitir al usuario utilizar de una forma sencilla y práctica la aplicación sin tener que preocuparse de nada en absoluto. Dentro de las mejoras podemos diferenciar las de dos tipos:

• De usuario (mejora la experiencia del usuario para con la aplicación)
  • Nueva interfaz de usuario
  • Nueva interfaz de búsqueda con nuevos filtros
  • Nuevo estilo de marcado de tareas pendientes y terminadas (imágenes en lugar de chekbox)
• De servicio (mejora la calidad del servicio de forma transparente al usuario)
  • Ajax combinado con XML
  • Mayor seguridad a la hora de intentar replicar sesiones

Por el momento la aplicación está optimizada, como ya hemos dicho, para navegadores modernos, es decir, últimas versiones de Chrome y Firefox, en este último caso, y para sacarle el máximo jugo a la interfaz, será necesario el uso de Firefox 4.0

http://diary.dipler.org

Muchos son los manuales que a día de hoy nos “enseñan”, o al menos eso dicen, a publicar con todo detalle los pasos para publicar nuestras aplicaciones para android en el market, y no digo que no sea cierta dicha aseveración, sino que, además deberían contar algunos inconvenientes a la hora de hacerlo, vamos a intentar proponer estos baches que a mi me han hecho perder un poco de tiempo para que no tengáis que perderlo vosotros también.

Este artículo parte de que todo lo que pone en el resto de páginas lo sabéis y no tenéis demasiado problema a la hora de hacer (en caso de dudas, preguntad sin temor en los comentarios de este artículo).

Lo más probable, es que si estás leyendo este artículo es que desarrolles aplicaciones para dispositivos con una versión de Android instalada superior a la 1.5.

A la hora de publicar para estas versiones aplicaciones hemos de tener en cuenta varios parámetros de fichero AndroidManifest.xml y, es que, para que se publique en el android para todos los dispositivos tendremos que decirlo expresamente en este fichero:

<manifest ...>
<uses-sdk android:minSdkVersion="4" />
 <supports-screens
 android:largeScreens="true"
 android:normalScreens="true"
 android:smallScreens="true"
 android:anyDensity="true" />

En estas líneas estamos diciendo que independientemente del tipo de pantalla de nuestro dispositivo, la aplicación va a ser compatible. Si no incluimos estas líneas, veremos como nuestra aplicación aparece en el Market para pantallas normales y grandes, pero no para pequeñas, es decir, en mi caso, la aplicación no se mostraba para mi HTC Wildfire, dispositivo en el que había estado haciendo todo el proceso de depurado de la aplicación.

Por otra parte, si deseamos publicar una aplicación de pago, deberemos tener una empresa registrada para darla como dato en la página de Google Checkout, la cual nos serviría para recibir pagos. Como alternativa recomiendo hacer uso de sistemas publicitarios en caso de que deseemos sacar algo de dinero de la aplicación y no tengamos empresa a la que asociar nuestra cuenta.

http://diary.dipler.org

Como ya comenté en el post de introducción de Diary 0.1.2, esa versión no era nada más que un aperitivo de la que estaba desarrollando en ese momento y, dado que algunas personas me recordaron lo incómodo que era el cambio de hora en los artículos escritos hice una pre-versión estable y la subí, pero no traía grandes cambios; esta sí:

• Las tareas pueden marcarse como terminadas o no utilizando el checkbox que hay a la izquierda del texto que hemos introducido (más tarde se añadirá búsqueda según el estado de las mismas)
• Mejorados los logs internos de funcionamiento
• Coloreadas las entradas de contenido en función del tipo
  • Diario: borde gris
  • Tarea: borde rojo
  • Idea: borde azul
• Mejorado el sistema de funcionamiento de ajax, basándose ahora en el intercambio de ficheros xml sencillos, permitiendo así gestionar varias partes de la ventana con una sola petición y por ende, mejorando la experiencia de usuario
• Añadido panel oculto en la parte superior que muestra mensajes de estado de la aplicación, estos pueden ser de tres tipos
  • OK
  • Alerta
  • Error

http://diary.dipler.org