Cómo solucionar el problema con el micrófono en los portátiles HP con Ubuntu

Cómo solucionar el problema con el micrófono en los portátiles HP con Ubuntu

Hasta ahora no me había dado cuenta de que el micrófono integrado en el monitor de mi portátil (un HP Pavilion dv6) con Ubuntu no funcionaba. Al tener instalado en otra partición Windows 7, las veces que he requerido de dicho hardware (Skype o cualquier juego con mis hijos) lo he hecho desde ese sistema operativo. Fue a raíz de la última actualización del navegador Chrome cuando reparé en el mal funcionamiento. Google Chrome ha habilitado la búsqueda por voz, de modo que se pueden realizar consultas habladas como si tecleáramos, incluso en lenguaje natural del tipo: “El tiempo para hoy en Valencia” o “Traducir manzana al alemán“.

Para solucionarlo debemos editar el fichero /etc/modprobe.d/alsa-base.conf, teniendo en cuenta que necesitamos permisos de superadministrador:

sudo gedit /etc/modprobe.d/alsa-base.conf

En él añadimos al final las siguientes líneas:

options snd_hda_intel model=laptop
options snd-hda-intel position_fix=1 enable=yes

Grabamos los cambios y reiniciamos el equipo. Tras reiniciar podemos abrir la configuración del sistema y en la sección Hardware pulsamos sobre Sonido. En la pestaña Entrada, podemos ver los dispositivos de entrada detectados: la línea de entrada frontal y la del micrófono interno. Desde aquí también podemos ajustar los niveles de entrada.

Pantalla de configuración del sonido en Ubuntu

 

 

Gráficos Estadísticos con jqPlot

En aplicaciones en los que introducimos una gran cantidad de datos, lo más lógico será posteriormente explotar esos datos y obtener estadísticas e informes. En este post presento jqPlot, una librería jQuery para generar gráficos estadísticos interactivos.

En aplicaciones en los que introducimos una gran cantidad de datos, lo más lógico será posteriormente explotar esos datos y obtener estadísticas e informes. En estos casos los datos obtenidos se visualizan de una manera óptima en gráficas que nos ayudan representar visualmente la gran cantidad de datos que en muchos casos hemos obtenido. Una manera fácil de generar gráficos estadísticos en aplicaciones web es utilizar javascript para mostrarlas en tiempo de ejecución.

La opción que utilizo para generar gráficas pasa por jQuery junto con jqPlot. Se trata de un plugin jQuery que genera gráficos estadísticos en el navegador dentro de tus páginas web. Soporta gráficas lineales, de barras y circulares (en forma de tarta). Tiene numerosas opciones de configuración como la inclusión de sombras y la interacción con eventos drag&drop. jqPlot ha sido probado en IE7, IE8 o superior, Firefox, Chrome, Safari y Opera. La licencia de uso es MIT y GPL versión 2, por lo que podemos utilizarlo libremente de forma gratuita en nuestros proyectos. Requiere jQuery (1.4.3 o superior para algunas características), la cual está incluida en la distribución.

Uso de la librería

Antes de nada debemos descargar jqPlot y lo podemos hacer desde la sección de descargas de la página del proyecto: http://www.bitbucket.org/cleonello/jqplot/

Para usar jqPlot debes incluir en tu página web: jquery, jqPlot, el fichero css de jqPlot y opcionalmente, el script excanvas para que tu página soporte canvas en Internet Explorer (esta característica HTML5 no la soportan las versiones de IE anteriores a la versión 9. Si es superior no es necesario incluir excanvas):

<!--[if lt IE 9]><script language="javascript" type="text/javascript" src="excanvas.js"></script><![endif]-->
<script language="javascript" type="text/javascript" src="jquery.min.js"></script>
<script language="javascript" type="text/javascript" src="jquery.jqplot.min.js"></script>
<link rel="stylesheet" type="text/css" href="jquery.jqplot.css" />

Lo siguiente es añadir el contenedor de la gráfica. Se trata de una capa a la que podemos darle si deseamos un ancho y un alto. Lo que es obligatorio es indicar un id.

<div id="chartdiv" style="height:400px;width:300px; "></div>

Creamos la gráfica llamando a la función jqplot, con dos parámetros obligatorios, el id de la capa contenedora y un array con los datos, normalmente enviados por el servidor y obtenidos desde base de datos. La invocación al método suele realizarse cuando la página está preparada:

<script type="text/javascript">
  <!--
  $(document).ready(function() {
    $.jqplot('chartdiv',  [[[1, 2],[3,5.12],[5,13.1],[7,33.6],[9,85.9],[11,219.9]]]);
  });
  -->
</script>

Esto generará una gráfica como la siguiente:

Gráfica lineal

Opciones de jqPlot

Podemos personalizar la gráfica pasando parámetros a la función como tercer parámetro, de la forma:

$.jqplot('chartdiv',  [[[1, 2],[3,5.12],[5,13.1],[7,33.6],[9,85.9],[11,219.9]]],
{ title:'Exponential Line',
  axes:{yaxis:{min:-10, max:240}},
  series:[{color:'#5FAB78'}]
});

Todas las opciones disponibles están descritas en el fichero jqPlotOptions.txt de la distribución.

Dependiendo de las características y de lo complejo que queramos que sea nuestra gráfica es posible que necesitemos incluir en nuestra página enlaces a otros plugins que se incluyen el la distribución jqPlot. Hay plugins para personalizar el renderizado de gráficas de barras con varias series, para personalizar la leyenda, las etiquetas en los ejes, etc:

<!--[if lt IE 9]><script language="javascript" type="text/javascript" src="js/jqplot/excanvas.min.js"></script><![endif]-->
<script type="text/javascript" src="js/jqplot/jquery.jqplot.min.js"></script>

<script type="text/javascript" src="js/jqplot/jqplot.pieRenderer.min.js"></script>    
<script type="text/javascript" src="js/jqplot/jqplot.barRenderer.min.js"></script>
<script type="text/javascript" src="js/jqplot/jqplot.categoryAxisRenderer.min.js"></script>
<script type="text/javascript" src="js/jqplot/jqplot.pointLabels.min.js"></script>
<script type="text/javascript" src="js/jqplot/jqplot.enhancedLegendRenderer.min.js"></script>

<link rel="stylesheet" type="text/css" href="css/jqplot/jquery.jqplot.css" />

Ejemplos

En el siguiente enlace se puede ver la librería en funcionamiento con varios ejemplos. A continuación algunas imágenes con diferentes tipos de gráficas:

Gráficas lineales: http://www.jqplot.com/tests/line-charts.php Gráfica lineal

Gráficas circulares: http://www.jqplot.com/tests/pie-donut-charts.phppiechart

Gráficas de barras: http://www.jqplot.com/tests/bar-charts.phpbarchart

Ni que decir tiene que jqPlot no es la única librería jQuery para la generación de gráficos estadísticos. A continuación os dejo dos enlaces a páginas dónde se enumeran varias alternativas:

 

Menú Contextual en tu Aplicación Web

Si necesitas incluir un menú contextual en tu página web, puedes hacerlo de una forma sencilla con el siguiente plugin jQuery

¿Quieres incluir un menú contextual en tu página web? Puedes hacerlo de una forma sencilla incorporando el plugin ContextMenu de jQuery. Se trata de un plugin ligero que te permite sobrescribir selectivamente el menú contextual del navegador al pulsar sobre el botón derecho del ratón. También comentaré la forma de que responda tanto a la pulsación sobre el botón derecho como al izquierdo.

Sus características son las siguientes:

  • Uso de múltiples menús diferentes en un página
  • Un menú puede ser asociado para que responda a varios elementos de la página
  • Los estilos de los menús son totalmente personalizables
  • Permite opciones de menú con iconos
  • Acciones asociadas a callbacks sensibles al contexto.

El único requisito es haber incluido en la aplicación el framework jQuery. Funciona en todos los navegadores, por lo que no tendremos problemas con compatibilidades. Puedes descargarlo desde aquí: jquery.contextmenu.r2.js para incluirlo en tus páginas o aplicaciones web

Uso

La estructura del menú se construye con HTML, incluyendo cada opción de menú en una lista no ordenada dentro de una capa, con la clase “contextMenu” y con el id que prefieras y que utilizarás para referenciarlo. Dentro de la página esta capa puede ir en cualquier posición.

Puedes definir tantos menús como necesites. Cada elemento <li> de la lista de la capa actuará como una opción de menú. Dando a cada <li> un id único las acciones pueden ser ligadas a ese menú.

A continuación se muestra un ejemplo. En la página HTML incluiremos el código del div del menú con las opciones que necesitamos:

    <div id="myMenu1" class="contextMenu" style="display: none">

      <ul>

        <li id="open"><img src="folder.png" /> Open</li>

        <li id="email"><img src="email.png" /> Email</li>

        <li id="save"><img src="disk.png" /> Save</li>

        <li id="close"><img src="cross.png" /> Close</li>

      </ul>

    </div>

El código javascript para enlazar cada opción con el código a ejecutar es el siguiente:

    $('span.demo1').contextMenu('myMenu1', {
      bindings: {

        'open': function(t) {
          alert('Trigger was '+t.id+'\nAction was Open');
        },

        'email': function(t) {
          alert('Trigger was '+t.id+'\nAction was Email');
        },

        'save': function(t) {
          alert('Trigger was '+t.id+'\nAction was Save');
        },

        'delete': function(t) {
          alert('Trigger was '+t.id+'\nAction was Delete');
        }
      }

    });

Menú de ejemplo

Parámetros

menu_id: Puedes asociar uno o más elementos de la página a un menú. Por ejemplo si invocamos al context menú de esta forma $("table td").contextMenu("myMenu1"), todas las celdas de una tabla mostrarán el menú al pulsar sobre ellas el botón derecho.

Configuración: Podemos usar la configuración por defecto o bien podemos opcionalmente  modificarla. En el ejemplo de arriba hemos visto cómo asociar la acción que se va a ejecutar para cada id del menú. Para añadir más deben ir separados por comas. El elemento que dispara el menú actual es pasado como parámetro.

  • menuStyle: Contiene pares nombre-valor para aplicar estilos al tag <ul> del menú.
  • itemStyle: Contiene pares nombre-valor para aplicar estilos a los elementos <li> del menú
  • itemHoverStyle: Idéntico al anterior pero aplica cuando se pasa el ratón sobre el elemento <li>, para resaltarlo, etc.
  • shadow: Boolean que identifica si se quiere mostrar la sombra del menú. Por defecto es true.

Puedes ver más en la página oficial del plugin. También es posible ampliar las opciones por defecto de todos los menús invocando al método defaults. Cualquier configuración excepto bindings puede ser usado como por defecto:

  $.contextMenu.defaults({
    menuStyle : {
      border : "2px solid green"
    },

    shadow: false,
    onContextMenu: function(e) {
      alert('Did someone asked for a context menu?!');
    }
  });

Menú contextual pulsando el botón izquierdo del ratón

Por defecto, este plugin funciona pulsando sobre el elemento que queremos que muestre el menú, con el botón derecho del ratón. Para modificar este comportamiento, y que se muestre igualmente al pulsar sobre el botón izquierdo, debemos abrir el fichero descargado del plugin (jquery.contextmenu.r2.js) y abrirlo para editar. Necesitamos modificar la línea:

return $(this).bind('contextmenu', function(e) {

por esta otra:

return $(this).bind('click', function(e) {

Tareas programadas con Spring y Quartz

En un post anterior explicamos cómo utilizar las clases wrapper de Spring para ejecutar una tarea a intervalos regulares de tiempo dentro de una aplicación web J2EE. En esta publicación integraremos Spring con el planificador Quartz para programar la misma tarea dentro de una aplicación J2EE. Quartz es un servicio opensource de planificación de tareas que puede ser integrado con cualquier aplicación Java, desde la más pequeña aplicación stand-alone al más extenso sistema de e-commerce

En un post anterior explicamos cómo utilizar las clases wrapper de Spring para ejecutar una tarea a intervalos regulares de tiempo dentro de una aplicación web J2EE. En esta publicación integraremos Spring con el planificador Quartz para programar la misma tarea dentro de una aplicación J2EE.

Quartz es un servicio opensource de planificación de tareas que puede ser integrado con cualquier aplicación Java, desde la más pequeña aplicación stand-alone al más extenso sistema de e-commerce. Quartz puede ser utilizado para crear planificaciones simples o complejas para ejecuciones de decenas, cientos, o incluso miles de trabajos cuyas tareas son definidas como componentes Java estándar. Además incluye soporte para transacciones JTA y clustering. Es de uso libre bajo la licencia Apache 2.0.

Para instalarla en nuestra aplicación simplemente descargaremos el fichero quartz-x.x.x.tar.gz desde la web de descargas y extraeremos el fichero quartz-all-x.x.x.jar para incorporarlo a nuestra aplicación. En mi caso utilicé la versión 1.8.6, pese a no ser la última, debido a mi versión de Spring. Si tienes problemas con la última, te recomiendo que vayas bajando de versión hasta dar con la idónea. Dentro del fichero comprimido tar.gz existe una carpeta lib con las dependencias que tiene quartz con otras librerías. En mi caso necesité incluir en mi aplicación la librería slf4j-api-x.x.x.jar.

Lo primero que vamos a crear es la tarea a ejecutar. Será un método público dentro de una clase pública, tal y como se muestra en el siguiente código:

package es.activity.schedule;

public class RunMeTask
{
	public void printMe() {
		System.out.println("Ejecutando tarea programada");
	}
}

A continuación abrimos para editar el fichero XML de contexto de nuestra aplicación web Spring y añadimos un bean que haga referencia a la clase anterior:

<bean id="runMeTask" class="es.activity.schedule.RunMeTask" />

Una vez definida la tarea pasamos a configurar los principales conceptos de Quartz: Job, Trigger y Scheduler:

Job

Es la unidad de trabajo o tarea a ejecutar. Sería cualquier implementación de la interfaz org.quartz.Job. En Spring se han incluido varias implementaciones de la interfaz pero nosotros vamos a utilizar MethodInvokingJobDetailFactoryBean, la cual nos permite la ejecución de un método de cualquier clase java:

<bean id="schedulerJob" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">
   <property name="targetObject" ref="runMeTask"></property>
   <property name="targetMethod" value="printMe"></property>
   <property name="concurrent" value="false"></property>
</bean>

Trigger

Es la unidad que conoce los detalles de la ejecución de la tarea y los instantes en los que se debe ejecutar. Sería cualquier implementación de la interfaz org.quartz.Trigger. Es este caso es el propio Quartz el que proporciona diversas implementaciones:

SimpleTrigger

Permite especificar una hora de comienzo, una hora de fin y un intervalo de ejecución, similar al ejemplo del post en el que hablábamos sobre la clase Timer incluida en el JDK. En el ejemplo ejecutamos el job tras un segundo de retardo y posteriormente cada 60 segundos.

<bean id="simpleTrigger" class="org.springframework.scheduling.quartz.SimpleTriggerBean">
        <property name="jobDetail" ref="schedulerJob" />
        <property name="repeatInterval" value="60000" />
        <property name="startDelay" value="1000" />
</bean>

CronTrigger

Permite especificar expresiones cron de Unix para establecer fechas y horas de ejecución del job. En el ejemplo se ejecuta el job de lunes a viernes a las 8 de la mañana.

<bean id="timerCronTrigger" class="org.springframework.scheduling.quartz.CronTriggerBean">>
        <property name="jobDetail" ref="schedulerJob"></property>
        <property name="cronExpression" value="0 0 8 ? * MON-FRI"></property>
</bean>

Más información sobre expresiones cron en los siguientes enlaces:

  1. http://en.wikipedia.org/wiki/CRON_expression
  2. http://www.quartz-scheduler.org/documentation/quartz-1.x/examples/Example3

Scheduler

Por último tenemos que lanzar la ejecución de nuestro job mediante un planificador que gestione la ejecución a partir de la información especificada en el Trigger. Spring incorpora la clase SchedulerFactoryBean para ejecutar uno o varios trigger:

<bean id="GiaScheduler" class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
        <property name="triggers">
            <list>
                <ref bean="timerCronTrigger"></ref>
            </list>
        </property>
</bean>

Con todo esto especificado en el fichero de contexto xml, desplegamos la aplicación en el servidor de aplicaciones y se ejecutará la tarea con la programación especificada.

 

Tareas programadas con Spring Framework y JDK Timer

Seguro que en más de una ocasión, durante el desarrollo de una aplicación has necesitado ejecutar una tarea de forma periódica. Para desarrollar esto, desde la versión 1.3 del JDK se incluye las clases java.util.Timer y java.util.TimerTask. Estas clase facilitan la programación de tareas para ejecuciones futuras en un thread en segundo plano.

Seguro que en más de una ocasión, durante el desarrollo de una aplicación has necesitado ejecutar una tarea de forma periódica. Para desarrollar esto, desde la versión 1.3 del JDK se incluye las clases java.util.Timer y java.util.TimerTask. Estas clase facilitan la programación de tareas para ejecuciones futuras en un thread en segundo plano. Las tareas pueden ser programadas para ejecutarse una vez o múltiples veces a intervalos regulares.

En el caso de que necesites una planificación más compleja, la clase Timer se quedará corta en varios aspectos y deberás utilizar un planificador como Quartz o similar. En este hilo de StackOverflow puedes ver otras alternativas. En este artículo vamos a utilizar las clases wrapper de Spring, que internamente hacen uso de las del JDK, para ejecutar una tarea a intervalos regulares de tiempo dentro de una aplicación web J2EE con el framework de Spring.

Lo primero que vamos a crear es la tarea a ejecutar. Será un método público dentro de una clase pública, tal y como se muestra en el siguiente código:

package es.activity.schedule;

public class RunMeTask
{
	public void printMe() {
		System.out.println("Ejecutando tarea programada");
	}
}

A continuación abrimos para editar el fichero XML de contexto de nuestra aplicación web Spring y añadimos un bean que haga referencia a la clase anterior:

<bean id="runMeTask" class="es.activity.schedule.RunMeTask" />

Vamos a definir a continuación, en el mismo fichero, el método de la clase que ejecutará el código de la tarea. Spring incorpora la clase MethodInvokingTimerTaskFactoryBean para reemplazar la clase TimerTask del JDK.

<bean id="schedulerTask" 
  class="org.springframework.scheduling.timer.MethodInvokingTimerTaskFactoryBean">
	<property name="targetObject" ref="runMeTask" />
	<property name="targetMethod" value="printMe" />
</bean>

Ahora vamos a definir cada cuánto se ejecutará utilizando la clase ScheduledTimerTask, que reemplaza a la clase Timer del JDK. Le pasamos como propiedades al bean tanto el retardo (delay) para la primera ejecución, como el intervalo (period) para sucesivas ejecuciones. Ambos valores en milisegundos. En el ejemplo se ejecutará un segundo después del despliegue de la aplicación y a continuación cada 60 segundos.

<bean id="timerTask"
	class="org.springframework.scheduling.timer.ScheduledTimerTask">
	<property name="timerTask" ref="schedulerTask" />
	<property name="delay" value="1000" />
	<property name="period" value="60000" />
</bean>

Hasta ahora se trata de configurar de manera declarativa lo referente a la tarea. Vamos a ejecutar el timer para que comience la ejecución:

<bean class="org.springframework.scheduling.timer.TimerFactoryBean">
	<property name="scheduledTimerTasks">
		<list>
			<ref local="timerTask" />
		</list>
	</property>
</bean>

Cómo ves no es necesario introducir ninguna llamada por código a la tarea programada. La clase TimerFactoryBean se encarga de ejecutar el código del método PrintMe() durante el despliegue de la aplicación en el servidor, con un retardo de 1 segundo la primera vez y luego cada 60 segundos.

Actualización (24/01/2013). Para completar la información quizás te interese cómo integrar Spring con el planificador Quartz. Por ello publiqué otro artículo posteriormente con el título “Tareas programadas con Spring y Quartz”.