Mostrando entradas con la etiqueta Programación. Mostrar todas las entradas
Mostrando entradas con la etiqueta Programación. Mostrar todas las entradas

¿Qué es una huella digital acústica?


Gracias al procesamiento de sonidos y el análisis de audio actualmente podemos contar con aplicaciones en nuestros dispositivos móviles que nos indican el título de una canción, el nombre del artista y hasta la letra de la canción. Algunas de las aplicaciones que pueden hacer tales funciones son SoundHound y Shazam.

Viendo las grandes posibilidades que tenemos actualmente los informáticos, me he dado a la tarea de investigar un poco en cómo trabajan dichas aplicaciones para poder replicar dicha funcionalidad pero ahora aplicándola a otras cosas que no sea la música que tenemos en la computadora. Primeramente veamos a qué le llamamos huella digital ( fingerprint ) y no hay que confundir a dicho término con la imagen visible que deja un dedo sobre una superficie ( huella dactilar ) ya que la huella digital es un mecanismo que permite identificar a un individuo.

De lo anterior podríamos decir que una huella digital acústica es es un pequeño resumen de un archivo de audio, por lo tanto una función f de la huella digital debe coincidir con un archivo de audio x, esto consiste en ir de un gran número de bits a una huella digital de sólo un número limitado de bits.

Actualmente en la UNSIJ estamos trabando en implementar algún algoritmo para crear hullas digitales acústicas de audio para poder almacenarlas en una base de datos, para después poder buscar coincidencias de audios similares.

Existen diversos métodos o técnicas para la identificación de contenido basada en una única y compacta firma ( hash ) derivada de los aspectos relevantes de una grabación de audio. Una función hash es una función que mapea un dato ( posiblemente grande y de tamaño arbitrario ) de un conjunto U a un dato pequeño, usualmente un número entero comprendido entre 0 y M − 1, el cual puede utilizarse como índice en un arreglo, por ejemplo. Al dato a mapear suele llamársele clave, mensaje o cualquier otro nombre dependiendo de la aplicación, mientras que al dato mapeado se le puede llamar valor hash, código hash, o simplemente hash.

hash : U −→ {0, 1, 2, 3, ..., M − 1}

Puesto que las funciones hash pueden mapear elementos de un conjunto más grande a uno más pequeño, es posible que dos o más claves sean mapeadas al mismo valor hash. En este caso se habla de una colisión. Una función hash optima sería aquella que no genere colisiones o que la probabilidad de éstas sea muy baja.

Más adelante intentaremos poner más información al respecto, pero por lo pronto podría servir que se visiten las siguientes ligas:


Por último, me gustaría agradecer a todos los que han visitado Cosmos y Caos haciendo posible las casi 30,000 visitas desde que inició el 16 de Marzo de 2011 ya que eso motiva a que siga publicando la información que podría ser de utilidad para todos ustedes.

Si quieres obtener más información sobre el trabajo de huellas digitales acústicas que estamos haciendo pues no dudes en leer el documento completo.

Problemas con acentos y ñ en JSP con MySQL

Resulta que trabajando con una página con JSP donde se debería poder capturar en un campo textArea de un Form un texto de máximo 200 caracteres pude toparme que no basta con tener configurado el tipo de codificación en la tabla de MySQL (yo lo tenía en latin1_spanish_ci) como se ve en la Figura 1.

Figura 1. Cotejamiento "latin1_spanish_ci"

Ya tampoco bastaba con tener la etiqueta META de especificación del conjunto de caracteres utilizados en la página con UTF-8 como se puede ver en la Figura 2.

Figura 2. Especificación del conjunto de caracteres para la página Web.

Aún me faltaba algo porque los textos me aparecían con símbolos raros como los mostrados en la Figura 3.

Figura 3. Texto con caracteres raros, no aparecía con acentos ni muestra Ñ.

Es por eso que buscando un poco en Internet, encontré la solución al problema en la página de A Wev0. Donde indica que se podría recodificar los datos obtenidos de MySQL al formato UTF-8 con la siguiente instrucción:

String msg=new String(request.getParameter("mensaje").getBytes("ISO-8859-1"),"UTF-8");

Así que con manos a la obra procedí a utilizarlo para convertir los datos y taran! como arte de magia el problema estaba solucionado!





Alternativa a conio.h en Linux Ubuntu usando curses.h

Para los que alguna vez aprendimos a programar con el famosos y antiguo Turbo C que si no mal recuerdo en ese entonces era de la extinta Borland, en esos ayeres pudimos ver que existían funciones como getch(), gotoxy(), color(); que eran parte de una biblioteca propia de Turbo C llamada conio.h y como no es parte del estándar ANSI C no la tenemos en Linux Ubuntu.

Bueno pues ésta entrada es para comentar que existe una biblioteca para Linux que aunque también no es parte del estándar ANSI C la podemos utilizar como alternativa a las funciones que teníamos en conio.h y aquí te digo qué tienes que hacer.

Primero que nada quiero comentar que actualmente estoy utilizando la versión 12.04 de Ubuntu por lo que lo que verás está con esa distribución de Linux.

Debes instalar los paquetes libncurses5-dev y libncursesw5-dev con:

sudo apt-get install libncurses5-dev libncursesw5-dev


Abres tu entorno de desarrollo y prueba escribiendo el siguiente código:


#include <curses.h>

int main() {
  initscr(); //activar el acceso a la pantalla
  clear(); //limpia la pantalla
  move(0,30); //mueve el cursos a la posición 0,30
  printw("Hola");
  refresh(); //mostrar en pantalla lo escrito por printw
  getch(); //espera la pulsación de una techa
  endwin(); //cerrar el acceso a la pantalla
  return 0;  
}



En lo personal me gusta mucho Geany como entorno de programación tanto para PHP como para lenguaje C así que comentaré que después de construir el programa y que puedas construirlo sin problemas tendrás que modificar el comando de construir desde el menú de Geany como se muestra en la siguiente captura:


Deberás poner la opción -lcurses al final del comando construir como se puede ver en la siguiente captura:


Por último, ejecuta el programa y podrás ver el funcionamiento de las funciones antes mencionadas. Bueno, por hoy es todo y no antes mencionar que la información fue vista en las siguientes ligas:

¿Cómo instalar el soporte para MS SQLServer en PHP desde Ubuntu?

Hace ya algunos días que actualicé mi lap a la versión 12.04 de Ubuntu y por desgracia perdía algunos enlaces antes de ese cambio y uno de esos enlaces que tenía guardados era justamente cómo instalar el soporte mssql en PHP.

El día de hoy por más que buscaba siempre encontraba la clásica solución de que tengo que descargar los fuentes de PHP para después compilar el módulo en cuestión y pues yo recordaba que existía una solución más fácil y por fin encontré la información en: Virtual Helpme y ahora pongo aquí la solución para que la tenga como recordatorio y para que otros también la puedan encontrar más fácilmente.

Ingresa a la terminal y escribe:

aptitude install php5-sybase

Después reinicia el Apache:

sudo /etc/init.d/apache2 restart

En el enlace de Virtual Helpme indican que algunas de las funciones del paquete mssql no están disponibles en el paquete php5-sybase y que para solucionarlo se debe instalar lo que pongo abajo pero hasta ahorita no lo he instalado y no he tenido problemas:

pear install --nodeps MDB2_Driver_mssql

Nos seguimos leyendo :)

Cómo instalar Oracle Java 7 en Ubuntu 12.04

Bueno pues resulta que Ubuntu ya está en su Beta 2 y lo tengo instalado en una DELL XPS M1210 funcionando a la perfección :) pero como quería utilizarla no sólo para pruebas pues decidí descargarme el Eclipse Indigo para hacer algunas prácticas con Java y al querer ejecutarlo que me manda el mensaje de que no existe Java instalado :( así que me decidí a buscar en la red cómo instalarlo en Ubuntu 12.04 y me encontré con algunas páginas (UnixMen) que indicaban que existe un PPA pero al querer instalarlo me daba el siguiente mensaje de error:


Como no se instalaba por más que leí y modifiqué algunas cosas del archivo oracle-java7-installer.postinst que se encuentra en /var/lib/dpkg/info/ pues no quedó de otra que buscar otra alternativa y les comento cómo lo conseguí:

Primero que nada ingresar a la página de descarga del Java SE Development Kit y seleccionar que aceptan la licencia de uso, después deberán descargar el archivo tar.gz que corresponda a su versión de Ubuntu 32 o 64 bits, dejo una imagen de la página de descarga:


Por lo general el archivo descargado lo dejamos en la carpeta Descargas por lo que tenemos que descomprimirlo y no importa que sea en la misma carpeta de Descargas:


Después desde la terminal hay que mover el directorio llamado jdk1.7.0_03 a /usr/lib/jvm/jdk1.7.0

sudo mv jdk1.7.0_02 /usr/lib/jvm/jdk1.7.0

Ahora tendrás que ejecutar los siguientes comandos desde la terminal:


sudo update-alternatives --install "/usr/bin/java" "java" "/usr/lib/jvm/jdk1.7.0/bin/java" 1
sudo update-alternatives --install "/usr/bin/javac" "javac" "/usr/lib/jvm/jdk1.7.0/bin/javac" 1
sudo update-alternatives --install "/usr/bin/javaws" "javaws" "/usr/lib/jvm/jdk1.7.0/bin/javaws" 1


Y después deberás ejecutar:

sudo update-alternatives --config java

Con lo que deberás ver en la terminal algo parecido a:
-------------------------------------------------------------------------------------------------------------

$sudo update-alternatives –config java
There are 3 choices for the alternative java (providing /usr/bin/java).

Selection Path Priority Status
————————————————————
* 0 /usr/lib/jvm/java-6-openjdk/jre/bin/java 1061 auto mode
1 /usr/lib/jvm/java-6-openjdk/jre/bin/java 1061 manual mode
2 /usr/lib/jvm/java-6-sun/jre/bin/java 63 manual mode
3 /usr/lib/jvm/jdk1.7.0/jre/bin/java 3 manual mode

Press enter to keep the current choice[*], or type selection number: 3
update-alternatives: using /usr/lib/jvm/jdk1.7.0/jre/bin/java to provide /usr/bin/java (java) in manual mode.
----------------------------------------------------------------------------------------------------------------

Y tendrás que seleccionar el número que le corresponda al jdk1.7.0 en el caso anterior es el número 3.

Ahora resta verificar que la versión utilizada será Oracle Java 7 y eso lo hacemos ejecutando desde la terminal:

java -version

Con lo que deberemos ver algo como:



Deberás repetir lo anterior ejecutando los siguientes comandos:

sudo update-alternatives --config javac
sudo update-alternatives --config javaws

Con eso deberás poder ejecutar tu Eclipse Indigo sin problemas :)

Fuente de instalación manual: askubuntu.com

Instalando MySQL Workbench en Ubuntu 11.10

Hace algún tiempo pude utilizar un programa llamado DBDesigner4 con el cual podía diseñar una Base de Datos (BD) relacional y después aplicar el modelo directamente a MySQL, además se podía hacer ingeniería inversa a una BD existente para crear su modelo y recuerdo que también decía que se podía utilizar con otros gestores de BD pero con el que más lo utilicé para las tareas escolares fue con MySQL y funcionaba bien.

DBDesigner4 desapareció pero pasó a llamarse MySQL Workbench y tiene licencia GPL y se puede descargar en su versión 5.2.37.



Pero con el pequeño inconveniente que sólo está en paquetes DEB para Ubuntu 10.04 y 11.04 y no para la versión Oneiric 11.10, así que hay dos alternativas, descargar el fuente de la página y compilarlo como se indica en esta página: Install MySQL Workbench from Source, o utilizando un PPA :) creado por Oliver Berten e instalándolo con las siguientes instrucciones:

sudo add-apt-repository ppa:olivier-berten/misc
sudo apt-get update
sudo apt-get install mysql-workbench-gpl

Actualmente estoy utilizándola de nuevo y al parecer todo funciona a la perfección, así que si quieres una herramienta poderosa y funcional para modelar tus nuevos proyectos y administrar tu servidor MySQL no dudes en utilizar MySQL Workbench.

Programando en lenguaje C sin conio.h

Después de un tiempo de no escribir regreso y es para comentar qué podemos hacer cuando estamos programando en C o C++ y no tenemos la biblioteca conio.h, la cuál contiene funciones muy útiles como la de gotoxy ( int x, int y ); que es una función que sirve para posicionar la salida en pantalla de los programas que se ejecutan desde la terminal (Linux) o consola (Windows).

Antes que nada comentar que conio.h es una biblioteca propietaria de la extinta Borland ( ahora Embarcadero Technologies ) por lo que cuando no utilizamos su compilador no vamos a encontrarla y nuestros programas no se podrán compilar, es por ello que buscando un poco en la red encontré estas dos formas de implementar la función gotoxy ( int x, int y ); y así no depender de una biblioteca propietaria.

Veamos el primer ejemplo el cual será ejecutado en Linux y mostrará en pantalla lo siguiente:



El código quedaría de la siguiente forma:

#include 
#include 

void gotoxy ( int x, int y );

int main(int argc, char **argv)
{
 int i;
 system("clear");
 for( i = 1; i <= 5; i++ )
 {
  gotoxy( i, 1 ); printf("*");
  gotoxy( i, 5 ); printf("*");
 }
 for( i = 2; i <= 5; i++ )
 {
  gotoxy( 5, i ); printf("*");
  gotoxy( 1, i ); printf("*");
 }
 return 0;
}

/* Implementación de la función */
void gotoxy ( int x, int y )
{
  printf("%c[%d;%df", 0x1B, y, x);
}

Para la ejecución de ese mismo programa en la consola de Windows la función gotoxy ( int x, int y ); quedaría de la siguiente forma:

void gotoxy ( int x, int y )
{
 COORD coord;
 coord.X=x;
 coord.Y=y;
 SetConsoleCursorPosition( GetStdHandle( STD_OUTPUT_HANDLE ), coord );
}

Programando el Demo1 con Glade, GTK y C++

Nuestro primer programa Demo1 será una ventana que contendrá 2 botones y una etiqueta, cuando el usuario presione el botón 1 aparecerá en la etiqueta el texto “Botón1 – Clicked” y cuando el usuario presione el botón 2 aparecerá en la etiqueta el texto “Botón2 – Clicked”, en la Imagen 1 podemos ver el resultado que obtendremos.

Imagen 1

Iniciaremos nuestro Demo1 creando la interfaz de usuario con la ayuda de Glade, al iniciar Glade nos mostrara una ventana de preferencias como la que vemos en la Imagen 2.

Imagen 2

Si queremos que nuestro programa sea mas compatible con la mayoría de los sistemas operativos anteriores podemos seleccionar la versión 2.14 de GTK+ aunque desde Ubuntu 10.04 seguramente ya se cuenta con la versión 2.16, otra cosa que debemos notar es que debe estar seleccionada la opción GtkBuilder que será la forma en que crearemos las referencias a los objetos desde nuestro código.


Una vez que se cierre esa ventana podremos iniciar nuestro programa y agregaremos nuestro primer Widget al editor visual y será una ventana de nivel superior (Imagen 3), como se observa en la parte derecha aparecerá el nombre del Widget “window1”.

Imagen 3


Luego agregaremos el GtkVBox (caja vertical) a “window1”, ese Widget nos servirá para organizar la forma en que podremos agregar mas componentes a nuestra ventana (Imagen 4), escribiremos que dividiremos en 2 la ventana principal, en la parte de arriba agregaremos un Label.

Imagen 4

En la parte de abajo agregaremos un Widget “GtkHButtonBox” y pondremos que vamos a trabajar con 2 elementos (Imagen 5). 
Imagen 5


Una vez hecho el paso anterior podremos modificar algunas propiedades de la caja de botones horizontal como se muestra en la Imagen 6.

Imagen 6




Y después agregaremos los dos botones correspondientes a la caja hbuttonbox1 y después cambiaremos el nombre a mostrar en cada botón como se muestra en la Imagen 7.


Imagen 7


Como se puede observar, la etiqueta a mostrar tiene el texto “_Boton1” y en la parte de abajo se cambio la opción: Utilizar subrayado a “Si”, lo anterior, con la finalidad de que al momento de presionar la tecla ALT se resalte la letra B para simular la acción click del ratón sobre el botón 1. De la misma forma, se cambiará la propiedad del botón 2 cambiándole el nombre a “B_otón2” y poniendo la opción de Utilizar subrayado a “Si”.

Por último, vamos a mencionar lo que son las señales, las señales son las funciones que se lanzan cuando se hace alguna acción sobre un Widget, como queremos que cuando se presione la X de la ventana principal se termine el programa, entonces tenemos que seleccionar el Widget “window1” y nos vamos a la pestaña de señales y seleccionamos “GtkObject” y después “destroy” para que seleccionemos de la columna “Manipulador” la opción “on_window1_destroy”. (Imagen 8)

Imagen 8

De la misma forma vamos a crear una señal para el botón 1 como se muestra en la Imagen 9.

Imagen 9

Guardamos nuestro archivo Glade como “demo1.glade” en el directorio donde vamos a trabajar con nuestro archivo de código C++.

Para editar el código C++ estoy utilizando Geany (Imagen 10) ya que me pareció un editor liviano que no consume muchos recursos y funcional, además de que tiene soporte para otros lenguajes de programación.

Imagen 10

Iniciaremos nuestro código "main.c" mencionando que tenemos que incluir la biblioteca "gtk.h" y para manipular los Widgets diseñados en Glade utilizaremos un tipo de dato estructurado llamado Demo1, para ello utilizaré la palabra reservada struct, veamos el inicio de nuestro programa:


/* Se importa la biblioteca gtk.h */
#include 

/* Definimos la constante con el nombre del archivo creado en Glade */
#define FILEGLADE "demo1.glade"

/* Estructura para almacenar los widgets las cual se necesita para manipularlos */
typedef struct
{
GtkWidget       *window;
GtkWidget       *boton1;
GtkWidget       *boton2;
GtkWidget       *label1;
} Demo1;

/* Declaración de las cabeceras de las funciones necesarias */

/* Función que se ejecuta cuando se lanza la señal 'click' del boton2 */
void on_click_boton2(GtkWidget *widget, Demo1 *demo);

/* El nombre de esta función se puso en la pestaña de Señales en Glade
* y se enlaza automáticamente a nuestro código */
void on_button1_clicked(GtkWidget *widget, Demo1 *demo);

/* Función que se ejecuta cuando se cierra la ventana principal */
void on_window1_destroy (GtkObject *object, gpointer user_data);

void error_message (const gchar *message); 

A continuación veremos la función principal "main()" en donde crean las variables Demo1 *demo; y GtkBuilder *builder; dichas variables nos servirán para construir los objetos de la interfaz de usuario y para almacenar en la estructura las referencias a dichos objetos para poder manipularlos.

int main (int argc, char *argv[])
{
/* Declaramos las variables a utilizar */
Demo1       *demo;
GtkBuilder  *builder;
GError      *err=NULL;

/* Localidad de memoria utilizada para la estructura Tutorial */
demo = g_slice_new (Demo1);

gtk_init (&argc, &argv);

/* Creación del constructor (builder) para después crear los widgets a partir del archivo XML
* creado desde glade */
builder = gtk_builder_new ();
if ( gtk_builder_add_from_file (builder, FILEGLADE, &err) == 0 )
{
error_message (err->message);
g_error_free (err);
return (1);
}

/* Obtener las referencias a los Widgets para almacenarlos en la estructura y poder manipularlos */
/* Primero obtenemos la referencia a la ventana principal */
demo->window = GTK_WIDGET (gtk_builder_get_object (builder, "window1"));
/* Primero obtenemos la referencia a los botones */
demo->boton1 = GTK_WIDGET (gtk_builder_get_object (builder, "button1"));
demo->boton2 = GTK_WIDGET (gtk_builder_get_object (builder, "button2"));
/* Obtenemos la referencia a la etiqueta */
demo->label1 = GTK_WIDGET (gtk_builder_get_object (builder, "label1"));

/* Se conectan las señales generadas por los objetos desde el builder con los widgets de la estructura */
gtk_builder_connect_signals (builder, demo);

/* Liberar memoria utilizada por el objeto GtkBuilder */
g_object_unref (G_OBJECT (builder));

gtk_widget_show (demo->window);

/* La otra forma de conectar a las señales directamente desde el código sin utilizar glade */
g_signal_connect(demo->boton2, "clicked", G_CALLBACK(on_click_boton2), demo);

gtk_main ();

/* Libera la memoria reservada para la estructura Demo1 */
g_slice_free (Demo1, demo);

return 0;
} 

El desarrollo de las funciones esta documentado sobre el mismo código que se pega a continuación:

/*
* Cuando el usuario presiona la X se ejecuta la opción gtk_main_quit()
* para salir de la función principal y terminar la aplicación.
*/ 
void on_window1_destroy (GtkObject *object, gpointer user_data)
{
/* Termina el ciclo gtk_main() */
gtk_main_quit ();
}

/*
* Señal que se ejecuta cuando el usuario dá click sobre el boton1
*/
void on_button1_clicked (GtkWidget *widget, Demo1 *demo)
{
/* función que agrega un texto a una etiqueta */
gtk_label_set_text(GTK_LABEL(demo->label1), "Botón 1 - Clicked");
}

/*
* Señal que se ejecuta cuando el usuario dá click sobre el boton2
*/ 
void on_click_boton2(GtkWidget *widget, Demo1 *demo)
{
/* función que agrega un texto a una etiqueta */
gtk_label_set_text(GTK_LABEL(demo->label1), "Botón 2 - Clicked");
}

/*
* Se llama error_message() cada vez que queremos mostrar un mensaje de error al usuario.
* Esto mostrará el mensaje de error en una ventana modal y también en la ventana de la terminal.
*/
void error_message (const gchar *message)
{
GtkWidget               *dialog;

/* Muestra el mensaje en la ventana (terminal) de comandos */
g_warning ("%s",message);

/* Crea un dialogo de mensaje de error y lo despliega de forma modal */
dialog = gtk_message_dialog_new (NULL, 
GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_ERROR,
GTK_BUTTONS_OK,
"%s",message);

gtk_window_set_title (GTK_WINDOW (dialog), "Error!");
gtk_dialog_run (GTK_DIALOG (dialog));      
gtk_widget_destroy (dialog);         
} 

Para finalizar les dejo la liga para descargar el código completo de la aplicación, recuerden compilarlo con la siguiente instrucción:


Compilar "main.c" usando el siguiente comando (Imagen 11):
  gcc -Wall -g -o demo1 main.c `pkg-config --cflags --libs gtk+-2.0` -export-dynamic

Imagen 11


Después ejecutar (Imagen 12):
  ./demo1


Cómo programar para GNU&Linux Gnome

Para el desarrollo de nuestro primer programa necesitaremos instalar Glade (Se encuentra en los repositorios de Ubuntu así que no tendremos problemas al querer instalarlo desde el Centro de Software. ver Imagen 1). Glade (Imagen 2) es una herramienta RAD (Desarrollo Rápido de Aplicaciones) visual para el modelado de interfases gráficas de usuario. Glade es independiente del lenguaje ya que no genera código fuente en ningún lenguaje en particular si no que se obtiene un archivo XML que puede ser importado (buscar GtkBuilder) y leído desde cualquier lenguaje compatible con GTK+ (Java, Python, C++, PHP, Ruby, por mencionar algunos).

Imagen 1

Imagen 2

Recomiendo instalar Devhelp ya que ahí encontraremos toda la información de la API (Interfase de Programación de Aplicaciones) GTK+.

También será necesario instalar “Archivos de desarrollo para libgklade2-dev” y si prefieres programar con Python también “python-gtk2-dev”.

GTK+ es una biblioteca de funciones para crear interfaces gráficas de usuario. Es funcional para muchas plataformas “UNIX-Like” y Windows. GTK+ tiene una arquitectura orientada a objetos basada en C que permite una máxima flexibilidad. GTK+ depende de las bibliotecas GLib, Pango, ATK, GdkPixbuf, GDK y GTK+.

En la siguiente entrada iniciaremos el desarrollo de nuestro primer programa Demo1.

Temas para fondos de escritorio en Ubuntu 10.04 y 10.10

Decidí iniciar un blog una vez que ya tengo un poco de material para dar a conocer y contribuir un poco con la comunidad desarrolladora de GNU&Linux, resulta que desde hace ya algunos años quería cambiarme del Sistema Operativo (SO) de las ventanas a GNU&Linux y por una u otra razón nunca hacía el cambio total, pero desde Septiembre del año pasado (2010) tomé esa decisión y no hubo vuelta atrás, me decidí por Ubuntu 10.04 y al poco tiempo cambié al 10.10 y en una siguiente entrada les comentaré más sobre la experiencia de cambio pero les puedo adelantar que no he regresado a las ventanas ni para tomar aire ni impulso ya que todo lo he encontrado en GNU&Linux.

El motivo de esta primera entrada es comentarles que encontré muy llamativa la opción que trae Ubuntu de poder seleccionar un grupo de imágenes (les llamé temas) como fondo de escritorio y que éstas se cambien automáticamente a medida que pasan algunos minutos, por default Ubuntu trae el grupo de imágenes del Cosmos (ver Captura 1) y las imágenes cambian cada 29 minutos con 5 segundos y se efectúa el cambio en los siguientes 5 segundos.

Captura 1

Debido a que me gustó esa opción de poder tener un grupo de imágenes me tomé la tarea de buscar un poco en Internet de cómo podría hacer mi propio tema de fondos de escritorio y encontré que si selecciono el tema de Cosmos y lo arrastro al escritorio (Captura 2) podría ver un archivo con formato XML (Archivo 1).

Captura 2

Información contenida en background-1.xml

  
    2009
    08
    04
    00
    00
    00
  

  
    1795.0
    /usr/share/backgrounds/cosmos/cloud.jpg
  
  
    5.0
    /usr/share/backgrounds/cosmos/cloud.jpg
    /usr/share/backgrounds/cosmos/comet.jpg
  
  
    1795.0
    /usr/share/backgrounds/cosmos/comet.jpg
  
  
    5.0
    /usr/share/backgrounds/cosmos/comet.jpg
    /usr/share/backgrounds/cosmos/earth-horizon.jpg
  
  
    1795.0
    /usr/share/backgrounds/cosmos/earth-horizon.jpg
  
  
    5.0
    /usr/share/backgrounds/cosmos/earth-horizon.jpg
    /usr/share/backgrounds/cosmos/blue-marble-west.jpg
  
  
    1795.0
    /usr/share/backgrounds/cosmos/blue-marble-west.jpg
  
  
    5.0
    /usr/share/backgrounds/cosmos/blue-marble-west.jpg
    /usr/share/backgrounds/cosmos/galaxy-ngc3370.jpg
  
  
    1795.0
    /usr/share/backgrounds/cosmos/galaxy-ngc3370.jpg
  
  
    5.0
    /usr/share/backgrounds/cosmos/galaxy-ngc3370.jpg
    /usr/share/backgrounds/cosmos/helix-nebula.jpg
  
  
    1795.0
    /usr/share/backgrounds/cosmos/helix-nebula.jpg
  
  
    5.0
    /usr/share/backgrounds/cosmos/helix-nebula.jpg
    /usr/share/backgrounds/cosmos/jupiter.jpg
  
  
    1795.0
    /usr/share/backgrounds/cosmos/jupiter.jpg
  
  
    5.0
    /usr/share/backgrounds/cosmos/jupiter.jpg
    /usr/share/backgrounds/cosmos/sombrero.jpg
  
  
    1795.0
    /usr/share/backgrounds/cosmos/sombrero.jpg
  
  
    5.0
    /usr/share/backgrounds/cosmos/sombrero.jpg
    /usr/share/backgrounds/cosmos/whirlpool.jpg
  
  
    1795.0
    /usr/share/backgrounds/cosmos/whirlpool.jpg
  
  
    5.0
    /usr/share/backgrounds/cosmos/whirlpool.jpg
    /usr/share/backgrounds/cosmos/cloud.jpg
  

Archivo 1

Al analizar un poco el archivo me dí cuenta que podría cambiar la ruta de las imágenes (<file>/usr/share/backgrounds/cosmos/whirlpool.jpg</file>) que yo quiero agregar al nuevo tema y también podría cambiar el tiempo en que se presentan estáticas en la pantalla (
<static>
    <duration>1795.0</duration>
) y el tiempo en que se cambian (
<transition>
    <duration>5.0</duration>
) pero ese trámite es un poco engorroso para aquellos que no queremos editar algún archivo siguiendo algún formato por lo que me decidí a desarrollar un programa gráfico (le llamo MyImageDesktop ver Captura 3) que nos ayude a seleccionar las imágenes que queremos agregar a un tema y además que me permita seleccionar el tiempo que me gustaría que permanezca en la pantalla antes de cambiarla por la siguiente y así contribuir un poco con la comunidad para enriquecer este SO.

Captura 3

MyImageDesktop está en la primera parte (v0.2) después de efectuar algunas pruebas, podemos agregar imágenes seleccionando el botón "Añadir" o bien seleccionando del menú "Editar" la opción "Agregar". Con eso nos presentará una ventana (Captura 4) donde podemos seleccionar el archivo JPG o PNG (por el momento solo JPG pero pronto agregaré los PNG) y podemos ver una vista previa en la parte de la derecha de la esa ventana. 

Captura 4

También podemos cambiar el tiempo en segundos en que la imagen permanecerá estática hasta que se cambie a la siguiente y podemos guardar nuestro archivo en cualquier lugar que queramos con el nombre que nos guste pero con terminación xml, para después arrastrar el archivo creado a las preferencias de la pantalla en la pestaña de Fondos de escritorio.

En la segunda versión de MyImageDesktop nuestro amigo Heladio nos agregó la funcionalidad de "Subir" y "Bajar" una fila de la lista de archivos con la finalidad de ordenar nuestros archivos a nuestro gusto :)

Por el momento es todo, les dejo los archivos necesarios para ejecutar MyImageDesktop. Para ejecutarlo debes descargar el archivo correspondiente a tu tipo de SO y descargar también el archivo MyImageDesktop.glade y colocarlos en el mismo directorio para después ejecutar desde una ventana (terminal) de comandos en el directorio donde se encuentran los archivos la instrucción ./MyImageDesktop

Ejecutable Ubuntu_x86 y Ubuntu_amd64
Fuente en lenguaje C

Error al compilar en Android Studio 4.0: CIRCULAR REFERENCE:com.android.tools.r8.a: Invoke-customs are only supported starting with Android O

Resulta que estuviste construyendo tu APP desde Android Studio 4.0 y no te marcó ningún tipo de error de codificación pero al querer compila...