Nosinmiubuntu | Ubuntu en concreto, GNU/Linux en general

Instalar R (paquete estadístico) desde código fuente

2012-02-09T19:30:00.006+01:00

R es un entorno libre orientado al cálculo estadístico que utiliza los lenguajes de programación C, C++ y Fortran para realizar las tareas solicitadas por el usuario, y que se caracteriza por la particularidad de que sus comandos se ejecutan desde una terminal. Instalar R en Ubuntu es realmente sencillo, pues está incluido en los repositorios de esta distribución; nos bastaría con un simple:

sudo apt-get install r-base

y ya tendríamos R instalado en nuestro sistema.

En esta entrada vamos a hacerlo un poco más difícil: instalaremos R desde su código fuente. Así conoceremos los pasos que constituyen el proceso estándar de compilación/instalación en Linux, y que son los siguientes:

./configure
make
sudo make install

Manos a la obra:

1) Nos bajamos el código fuente de R (http://cran.freestatistics.org/src/base/R-2/R-2.14.1.tar.gz).

2) Abrimos una terminal y descomprimimos el archivo R-2.14.1.tar.gz:

$ tar xvzf Descargas/R-2.14.1.tar.gz

3) Entramos en el directorio del código fuente de R y ejecutamos ./configure. Este script comprueba las dependencias necesarias para la compilación; si todas ellas están disponibles se creará un archivo Makefile, necesario para la posterior ejecución de make. En caso contrario, ./configure nos irá detallando qué dependencias faltan:

$ cd R-2.14.1
$ ./configure
configure: error: no acceptable C compiler found in $PATH
See `config.log' for more details

* No hay compilador de C. Lo instalamos (de paso también instalamos make) y probamos de nuevo:

$ sudo apt-get install gcc make
$ ./configure
configure: error: No F77 compiler found

* No hay compilador de Fortran. También lo instalamos:

$ sudo apt-get install gfortran
$ ./configure
configure: error: --with-readline=yes (default) and headers/libs are not available

* No se encuentra la librería de desarrollo (dev) readline:

$ sudo apt-get install libreadline-dev
$ ./configure
configure: error: --with-x=yes (default) and X11 headers/libs are not available

* Falta la librería de desarrollo (dev) xorg:

$ sudo apt-get install xorg-dev
$ ./configure

¡Por fin! Esta vez ./configure nos confirma que ya disponemos de todas las dependencias, pues, como podemos observar, el script completa su ejecución:

4) Lanzamos make, que se encargará de leer y ejecutar todas las órdenes de compilación contenidas en el recién creado Makefile:

5) Compilado. En este punto del proceso, ya podríamos utilizar R sin necesidad de instalarlo a nivel de sistema (para todos los usuarios); sólo tendríamos que hacer ./bin/R :

6) Pero vamos a hacer que esté disponible para todos con sudo make install :

Con el comando which confirmamos que el ejecutable de R se encuentra en /usr/local/bin.

Saludos.

Google Analytics en Android

2012-02-08T13:21:00.002+01:00

Buenas, hace poco he integrado las estadísticas de Google Analytics en una aplicación que estoy preparando. La verdad es que visto al final, el proceso no parece muy complicado, pero ir siguiendo los diferentes pasos a través de diferentes páginas y en inglés puede llegar a ser un tema que se le puede atragantar a más de uno. Hoy veremos como hacer esto en unos sencillos pasos.

Lo primero que tenemos que hacer es acceder con nuestra cuenta Google en la web de Google Analytics. Las pasos a seguir los voy a hacer con la nueva interfaz de Google por lo que puede variar algo para los que teneis la antigua. Pinchamos en el icono de administración de cuentas (barra naranja a la derecha), ahi teneis un botón para crear una cuenta nueva. Por cada una de vuestras aplicaciones creareis una.

Para los que ya han añadido estas estadísticas en una página web, deciros que son los mismos pasos, solo que con alguna pequeña diferencia. Le damos nombre a nuestra cuenta e indicamos que no es una página web, aunque podéis poner que es una web e inventaros el dominio, por ejemplo con el espacio de nombres de vuestro proyecto o con un subdominio de alguna web vuestra.

Una vez rellenado todo, guardamos, y nos quedamos con el id de seguimiento, olvidándonos de todo el javascript que nos da (solo es necesario si lo integramos en una web). Además nos muestran un botón para descargar el SDK de Android. Desde aquí vais a la zona de descargas y descargais la versión para Android.

Descomprimimos el archivo, dentro de este tenemos un archivo libGoogleAnalytics.jar y algún ejemplo para integrar en nuestras aplicaciones. Lo que hago normalmente es en la carpeta donde tengo mis proyectos, tengo una carpeta libs para tener a mano siempre estas librerias que voy descargando.

Lo que si que teneis que hacer es abrir vuestro proyecto, y crear una carpeta llamada libs en el raíz de la aplicación, y colocar aquí el archivo .jar. Ahora hacemos botón derecho sobre el nombre de nuestro proyecto y vamos a Properties -> Java Build Path -> Pestaña Libraries -> Botón add jars... en la pantalla que aparece buscamos nuestro proyecto y seleccionamos el archivo jar de la carpeta libs, y aceptamos todo.

Ahora en el archivo AndroidManifest.xml añadimos los siguientes permisos para que la librería pueda funcionar, acceder a internet y comprobar el estado de nuestra conexión para registrar las visitas.

<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />

Y vamos a crear una clase para que sea más sencillo utilizar las estadísticas en toda nuestra aplicación, le llamaremos AnalyticsManager:

private GoogleAnalyticsTracker tracker;
 private String UA_Code;
 private int frecuencyUpdateGoogle = 60;
 private Context context;
 
 private GoogleAnalyticsTracker getTracker(){
  if(tracker == null){
   tracker = GoogleAnalyticsTracker.getInstance();
   tracker.startNewSession(UA_Code, frecuencyUpdateGoogle ,this.context);
  }
  return tracker;
 }
 
 public AnalyticsManager(Context context,String UACode){
  this.context = context;  
  this.UA_Code = UACode;
 }
 
 public void registerPage(String page, String parameter){
  this.getTracker().trackPageView("/" + page+ "/" + parameter);
 }
 
 public void registerPage(String page){  
  this.getTracker().trackPageView("/" + page);
 }
 
 public void registerAction(String Category, String Action, String Label, int Value){
  this.getTracker().trackEvent(Category, Action, Label, Value);
 }
 
 public void stopTracker(){
  if(this.getTracker() != null)
   this.getTracker().stopSession();
 }
}

La clase no es muy extensa, en el constructor le pasamos el context donde estamos y el id de seguimiento o UA_Code de Google. El UA_Code lo podéis guardar como una variable global, como veremos después, y de esta forma podéis exportar esta clase a cualquiera de vuestros proyectos. La frecuencia de refresco está en 60 segundos, si lo creéis oportuno, ajustad este parámetro a vuestras necesidades.

Para registrar estadísticas tenéis el método registerPage al cual podéis indicar el nombre de la página, aquí será una activity, a la que navega el usuario, y podéis indicar también un parámetro más por si es una vista que muestra el detalle de algún ítem, y podáis saber hacia cuales navegan vuestros usuarios.

El otro método es registerAction y va a permitirnos registrar cuales son los botones, acciones etc... que más utilizan los usuarios. Podemos indicar la categoría, acción, etiqueta y valor de nuestros botones.

Llegados a este punto ya tenemos totalmente operativa nuestra aplicación, a partir de aquí sería tan fácil como instanciar esta clase y llamar a estos métodos cuando los necesitemos. Advertiros que Google no va a empezar a reflejar el histórico de las estadísticas hasta pasado un día, pero, hay una opción en la que podéis ver las estadísticas en tiempo real de los últimos 30 minutos y no necesitáis esperar un día para saber si está funcionando o no las estadísticas.

Ahora os voy a enseñar como registro en mi aplicación las estadísticas. Por un lado me creo una clase AppGlobals que hereda de Application y me permite acceder a propiedades u objetos que quiero tener de forma global en mi aplicación. Una vez creada teneis que abrir el archivo AndroidManifest.xml y en la pestaña Application chequeais la opción Define an <application> tag in the AndroidManifest.xml y en Name pinchais en Browse y os aparecerá la clase AppGlobals, la seleccionais y guardais.

En la clase AppGlobals vamos a tener el siguiente código, los métodos son static, de esta forma no es necesario instanciar esta clase para llamarlos:

public static String getUACodeAnalytics(){return "UA-xxxxxxxxx-x";}
private static AnalyticsManager analyticsManager = null;

public static AnalyticsManager getAnalyticsManager(Context context){
 if(analyticsManager == null)
  analyticsManager = new AnalyticsManager(context,getUACodeAnalytics());
 return analyticsManager;
}
 
public static AnalyticsManager getAnalyticsManager(){
 return analyticsManager;
}

Lo que estamos haciendo aquí es utilizar el AppGlobals para poder llamar la clase analytics, está ya se encarga de crear el objeto y pasarle el UA_Code si es necesario, de esta forma utilizarlo desde nuestras activitys es muy fácil, solo tenemos que hacer una llamada más o menos así pero utilizando registerPage o registerAction según vuestras necesidades y con los parámetros que consideréis oportunos:

AppGlobals.getAnalyticsManager(this.getApplicationContext()).registerPage("MainMenu");

Para abrir una nueva activity también suelo tener una clase donde tengo todas las llamadas a mis activitys localizadas, de esta forma si tengo que cambiar, como por ejemplo el nombre de la visita solamente hago el cambio aquí. Este es un tema diferente que no voy a tratar aquí pero seguramente no tardaré en hacerlo.

Instalar un servidor DHCP en Ubuntu

2012-02-07T19:00:00.004+01:00

Comenzamos la parte práctica de los 2 últimos artículos, para así tener nuestro servidor DHCP en casa, o en cualquier entorno doméstico, configurado a nuestra manera, cubriendo nuestras necesidades y librándonos de asignar manualmente las opciones de red.

Tenemos nuestro Ubuntu preparado, así que vamos a ver los pasos de la instalación del servicio.

Requisitos

Lo primero es entender el concepto de las direcciones IP.

Saber para qué sirve un servidor DHCP.

Tener instalado el webmin, y que ya te explicamos cómo. (También te puede interesar potenciar webmin).

Asignar una IP fija (o estática). Es recomendable (obligatorio) para todos los tipos de servidores que montemos en un ordenador, tenerlos localizados siempre en la red. Así que si no está asignado ya, aquí tenéis el artículo dónde podréis cambiar la IP.

Detalles a tener en cuenta

Lo normal en una red local, es que nuestro router funcione como servidor DHCP y asigne la configuración de red. Con lo cual, si tenemos este servicio funcionando, es recomendable que se desactive. Esto se debe a que no se puede asignar una dirección IP a dos ordenadores, y si esto ocurre, da un error de conflicto de IP. Y el que primero la tenga asignada, se quedará con ella,y el segundo se quedará con una dirección alternativa.

También debemos planificar nuestro mapa de equipos en la red, y sus respectivas asignaciones de IP.

Otro detalle más que obvio, es que si el servidor en dónde lo instalamos está apagado, ningún ordenador que se conecte posteriormente recibirá la información de red, y obviamente, no tendrá acceso a la misma.

Instalación

Lo primero, es instalar el software que nos permita que nuestro ordenador funcione a modo DHCP. Para ello, como buenos usuarios de ubuntu que somos, utilizaremos el terminal.

$ sudo apt-get install dhcp3-server

Con esto instalaremos el software que necesita el ordenador, y si necesitamos dependencias:

$sudo apt-get install -f

Ya está. Simple ¿no?

El siguiente paso (como ya tenemos instalado webmin) es entrar en él:

https://localhost:10000

Y una vez dentro refrescaremos los módulos, y nos dirigiremos a la pestaña de servidores, y comprobaremos que lo reconoce.

Dejamos esta semana la publicación aquí, y en una semana, nos ocuparemos de configurarlo!

Es mucho más importante esa parte que ésta, pero sin este artículo no se puede realizar la segunda.

Un saludo.

La importancia de las actualizaciones

2012-02-06T22:11:00.000+01:00

Si hay algo que aventaja claramente a Ubuntu con respecto a otras distribuciones es su frecuencia de actualización; cada pocos días aparecen nuevas versiones de los diferentes elementos que integran este sistema operativo, así como parches que aportan mejoras o funcionalidades extra a las versiones ya instaladas. Además, también es muy importante que el sistema se mantenga actualizado por motivos de seguridad, y aquí es a donde yo quería llegar...

No hace mucho, el amigo de Así somos Linux me comentó la existencia de un problema de seguridad en el kernel 2.6.39 y superiores, el cual permitía a cualquier usuario convertirse en root o administrador sin conocer su contraseña. Ni corto ni perezoso, decidí buscar el exploit (pequeño programa que aprovecha una determinada vulnerabilidad del sistema) y ponerlo en práctica. El nombre de dicho exploit es mempodipper, fue programado por zx2c4, y se aprovecha de un bug en el manejo de los permisos del directorio /proc/pid/mem, utilizado para leer y escribir directamente en la memoria de los procesos.

Una vez descargados los archivos necesarios, compilé el exploit (ejecutable resultante subrayado en rojo):

Y procedí a ponerlo en marcha. Fijaos en la salida del comando whoami antes y después:

En efecto, me había convertido en root.

Como en muchas otras ocasiones, ya hay un parche disponible, esta vez publicado por el propio Linus Torvalds. Para probar este exploit utilicé BackTrack 5 R1 (32 bits) con versión de kernel 2.6.39.4. Sin embargo, también lo compilé y ejecuté en Ubuntu 11.10 (64 bits) con el kernel actualizado mediante repositorios, y el exploit ya no funcionó.

Un saludo.

El Escritorio del Lector #62

2012-02-05T21:39:00.000+01:00

Para finalizar la semana, y como es ya una costumbre, volvemos con "El Escritorio del Lector". No me cansaré de repetir que es una sección que me ha sorprendido muy gratamente, ya que vosotr@s sois los que la hacéis seguir enviando vuestras capturas y características. Es muy gratificante que os impliquéis con el blog, así que desde aquí os agradecemos que sigáis participando y comentando.

Nuestro visitante #62 es Hereldar, quien muy amablemente nos ha enviado todas las especificaciones, usuario de Kubuntu, y que nos ha enviado una descripción de los motivos de su escritorio, que os cito a continuación:

"Utilizo dos barras verticales para ahorrar espacio en pantalla, soy programador y mi pantalla es demasiado alargada para mi gusto. Al principio probé con una sola barra a la izquierda pero no me gustaba el resultado, al final quedó como veis."

S.O.: Kubuntu

Tema de Plasma: Caledonia

Tema de iconos: Faenza

Decoración de ventanas: Oxygen

Esquema de colores: Norway

Fondo de escritorio: Caledonia for Kubuntu

Desde aquí os animo (algo que agradezco de antemano) a participar enviando vuestra captura o capturas con sus correspondientes características, como Sistema Operativo, Fondo de Escritorio, Tema de Ventanas y Tema de iconos a nosinmiubuntublog@gmail.com

Saludos.

Particionado GPT

2012-02-02T12:00:00.019+01:00

Muchos de vosotros conocéis las limitaciones del sistema de particionado clásico, basado en un registro de arranque maestro (Master Boot Record o MBR); este método para gestionar/repartir el tamaño de nuestros discos duros se caracteriza por lo siguiente:

1) Se admite un máximo de 4 particiones primarias, o bien 3 particiones primarias y 1 extendida, pudiendo esta última albergar particiones lógicas.

2) Cada partición no puede sobrepasar los 2,2 TB o terabytes de tamaño, por lo que con 4 particiones primarias, o 3 primarias y 1 extendida, nunca podríamos gestionar más de 8,8 TB.

Gracias a Intel y a su proyecto EFI (Extensible Firmware Interface) estas “limitaciones” han pasado a la historia, y escribo limitaciones entre comillas porque, a día de hoy, supongo que pocos usuarios medios necesitan un elevado número de particiones o un disco de 8,8 TB. Este proyecto no es ni mucho menos reciente, pues Intel comenzó a trabajar en él a mediados de los 90, y en el 2005 ya tenían fundación propia, conocida como UEFI (Wikipedia).

Para comprobar si nuestro equipo permite el uso de EFI, haciendo:

(para Ubuntu <= 10.10) zcat /proc/config.gz | grep CONFIG_EFI=
(para Ubuntu > 10.10) cat /boot/config-`uname -r` | grep CONFIG_EFI=

deberíamos encontrar una línea CONFIG_EFI=y.

Con el estándar EFI disponemos de un nuevo método de particionado que nos libera del viejo sistema MBR. Este método se denomina GPT (GUID Partition Table) y, a grandes rasgos, nos aporta las siguientes ventajas:

1) Se admite un máximo de 128 particiones primarias.

2) Cada partición puede llegar a un tamaño de 9,3 ZB o zettabytes (1 zettabyte = 1 billón de terabytes).

Como todavía no dispongo de un disco duro de 10 ZB (ni de 10 TB), vamos a ver un ejemplo de particionado GPT en un disco de 160 GB, donde sobrepasaremos el límite de 4 particiones primarias propio de MBR; para llevar esto a cabo no nos sirve el mítico fdisk, si no que tendremos que recurrir a su pariente cercano gdisk. Instalarlo es tan sencillo como hacer un sudo apt-get install gdisk.

Empecemos:

En este caso, el disco duro es /dev/sdc, así que:

Antes de continuar, es necesario conocer los códigos para cada tipo de partición; para visualizar dichos códigos, pulsamos l + Enter:

El código correspondiente a una partición Linux es 0700, y el perteneciente a una partición Linux Swap es 8200.
Vamos a crear 5 particiones primarias de 10 GB cada una; 4 de ellas van a ser particiones Linux, y la última será una Linux Swap:

Como podéis adivinar, para crear una nueva partición basta con pulsar n + Enter. Sólo necesitamos introducir el tamaño (+10G) y el tipo de partición (0700 ó 8200). Pulsando p + Enter se nos muestran las particiones recién creadas:

Ahí están nuestras 5 particiones primarias. Bastará con teclear w + Enter para salir de gdisk guardando los cambios realizados.

Nota: Sólo he verificado el reconocimiento de particiones GPT en Trisquel 4.0.1, Ubuntu 11.10, Fedora 16, openSUSE 12.1 y BackTrack 5. Para otras distribuciones de Linux, consultad las documentaciones o manuales correspondientes.

Un saludo.

Leyendo servicios web desde Android: JSON

2012-02-01T12:40:00.004+01:00

Buenas, estas dos semanas anteriores vimos como instalar en Ubuntu un entorno de desarrollo para PHP y MySQL y luego creamos nuestro primer servicio web para poder leerlo desde cualquier dispositivo (Android, IPhone, otro sitio web...). La semana pasada nos quedó pendiente ver como utilizar este servicio web en una aplicación Android, así que vamos allá.

En el ejercicio de esta semana lo que vamos a hacer es conectarnos a nuestro servidor, leeremos y parsearemos el JSON que nos devuelva y por último lo guardaremos en base de datos en nuestro dispositivo.

Para los que no tenéis un servidor donde realizar las pruebas no os preocupéis, con vuestro dispositivo y un router wifi podéis probarlo sin problema.

Empezamos. Lo primero que haremos es abrir Eclipse. En un proyecto nuevo crearemos una nueva clase llamada JSONManager la cual va a tener el siguiente método static y public:


 public static JSONObject getJSONfromURL(String url){
     InputStream is = null;
     String result = "";
     JSONObject json = null;
      try{
         HttpClient httpclient = new DefaultHttpClient();
         HttpPost httppost = new HttpPost(url);
         HttpResponse response = httpclient.execute(httppost);
         HttpEntity entity = response.getEntity();
         is = entity.getContent();
     }catch(Exception e){}

      try{
         BufferedReader reader = new BufferedReader(new InputStreamReader(is,"iso-8859-1"),8);
         StringBuilder sb = new StringBuilder();
         String line = null;
         while ((line = reader.readLine()) != null) {
             sb.append(line + "\n");
         }
         is.close();
         result=sb.toString();
     } catch(Exception e){}

     try{
         json = new JSONObject(result);
     }catch(JSONException e){}

      return json;
 }

El método se conectará a la URL que le indiquemos y tratará de leer y parsear la respuesta en un objeto JSONObject. La primera parte del método abre la conexión http y obtiene la respuesta en un InputStream. La segunda parte, lee la respuesta y la parsea con un objeto BufferedReader para poder finalmente pasarla a un String. Este String es necesario en la tercera parte para crear un nuevo objeto JSONObject que será lo que vamos a devolver finalmente.

Para la siguiente parte creamos una nueva clase, la cual voy a llamar JSONParserLibros. Esta clase se va a encargar de leer el servicio ayudado del método anterior y guardar en base de datos. Veamos que es lo que hace.


private Activity activity;
private JSONObject jObject; 
private ProgressDialog progressDialog = null;
private Runnable runReadAndParseJSON;

public JSONParserLibros(Activity a){
   activity = a;
}

public void readAndParseJSONLibros() throws JSONException{
   runReadAndParseJSON = new Runnable() {
      @Override
      public void run() {
       try{
          readJSONLibros();
       } catch(Exception e){}
      }
   };
   Thread thread = new Thread(null, runReadAndParseJSON,"bgReadJSONLibros");
   thread.start();
   progressDialog = ProgressDialog.show(activity, "Descargando información", "Por favor espere",true);
}

private void readJSONLibros() throws JSONException{
   jObject = JSONManager.getJSONfromURL("http://192.168.1.87/android/service.libros.php");
   if(jObject != null)
          parseJSONLibros(jObject.getJSONArray("libros"));
   activity.runOnUiThread(returnRes);
}

private void parseJSONLibros(JSONArray librosArray) throws JSONException{
  for(int i = 0; i < librosArray.length(); i++){
     Libro l = new Libro();
     l.setIdLibro(librosArray.getJSONObject(i).getInt("id"));
     l.setTitulo(librosArray.getJSONObject(i).getString("libro"));
     l.setISBN(librosArray.getJSONObject(i).getString("isbn"));
     l.save(activity);
  }
}

private Runnable returnRes = new Runnable(){ 
 @Override 
 public void run() {
  progressDialog.dismiss();
 }
};

Como veis, tiene bastantes métodos, vamos a ver que hace cada uno. Lo primero que nos encontramos son variables y el contructor de la clase.

A continuación tenemos el método público que utilizaremos para llamar a nuestro servicio readAndParseJsonLibros. Este método crea un nuevo hilo de ejecución dentro del cual se va a hacer la llamada al servicio web, además se inicia una ventana de dialogo que avisará al usuario que se está haciendo una descarga.

La razón de hacerlo en un hilo de ejecución diferente es porque este es un proceso asíncrono que va a depender de diferentes factores como la velocidad de la conexión o de lo que tarde en responder el servidor.

El siguiente método readJsonLibros es private, y va a obtener el objeto JSON resultante de la llamada a nuestro servicio web mediante el método de la clase JSONMananger. Lo que hacemos a continuación es buscar el array de objetos json incluido dentro de libros. Aquí lo que vamos a tener es cada uno de los objetos json libro. Por último, se llama a un objeto Runnable definido al final de la clase que lo que va a hacer es cerrar la ventana de diálogo.

Como veis, he puesto una IP de una red local para hacer la llamada al servicio, esta corresponde al equipo donde he desarrollado el servicio web. En el momento de probar esto, si teneis un router wifi, deberéis activar la conexión wifi en vuestro dispositivo Android y conectaros a vuestra red local para que podáis tener acceso al servicio. En caso de no tener wifi teneis otras opciones como montar el servicio web en un servidor en internet, los datos se descargarán echando mano de vuestra conexión 3G , o también lo podeis probar con el emulador de Android.

Por último está el método parseJSONLibros, este simplemente recorre el array que obtuvimos antes, en cada una de las vueltas se a tener acceso a un objeto json libro, el cual tiene las propiedades: id, libro e isbn. Podemos acceder al objeto mediante librosArray.getJSONObject(i), donde i es la posición que queremos recuperar, y para acceder a las propiedades simplemente con getInt("nombre") o getString("nombre") dependiendo del tipo de dato que tengamos que recuperar.

Por último, en mi caso me he creado un objeto Libro, al cual seteo las propiedades correspondientes y llamo al método save para guardar en la base de datos de la aplicación. No os pongo como sería esta parte porque ya hemos tratado cómo guardar datos en base de datos SQLite también podéis ver el resultado de lo que habéis descargado leyendo los datos de la base de datos.

Para utilizar esta clase simplemente debereis crear una instancia del objeto JSONParserLibros y llamar al método readAndParseJSONLibros en la parte de vuestra aplicación que más os interese. Utilizada en el método OnCreate de una Activity quedaría de la siguiente forma:


JSONParserLibros json = new JSONParserLibros(this);
json.readAndParseJSONLibros();

Uno de los aspectos que debeis tener en cuenta también es la frecuencia con la que se actualizan vuestros contenidos, si los libros se actualizan de media cada 2 días lo que podeis hacer es guardar en las SharedPreferences la última fecha de actualización y en el método público readAndParseJsonLibros verificar que hayan pasado 2 días o más para llamar a vuestro servicio. Cada vez que hagais lectura reescribis esta fecha con la fecha actual.

Bueno, hasta aquí la última parte de esta serie de capítulos dedicados a los servicios web. Espero os sean de ayuda. Por último, os voy adelantando el tema de la semana que viene, como registrar visitas con Google Analytics en nuestra aplicación Android.

DHCP, El asignador de IP

2012-01-31T16:00:00.002+01:00

Continuamos en nuestro camino, y tras ya saber qué es una IP, y para qué sirve en el anterior artículo, hoy vamos a dar un paso hacia más y saber qué es un servidor DHCP y cuáles son sus funciones dentro de una red. Y descubriremos que está basado en el protocolo IP, y que es un servicio muy confortable.

¿Que significan las siglas DHCP?

Las siglas en inglés: "Dynamic Host Configuration Protocol", en español vendría a ser algo así como: Protocolo de configuración dinámica de host. Esto significa en primera instancia, que es un protocolo, un método estándar para que cualquier dispositivo pueda interactuar con este tipo de servicio. También gracias a su denominación, podemos observar que sirve para configurar un host, ya sea éste un ordenador, un móvil o cualquier dispositivo que pueda conectarse a la red. Y la última palabra es "dinámica", esto significa que no es necesario hacerlo de forma manual, que es un proceso automático.

¿Para qué sirve el servicio DHCP?

Este protocolo, permite que haya una comunicación entre un dispositivo conectado a una red y el propio servidor DHCP. Esta comunicación se basa en el formato cliente-servidor mediante el cual un cliente, como puede ser un ordenador, pide cierta información al servidor, que se la asigna mediante unos parámetros previamente asignados.

¿Qué información puede asignar un servidor DHCP a un cliente?

Como ya hemos visto, los servidores brindan información a un cliente (host), con el fin de simplificar las configuraciones de red. Esta puede ser:

Dirección IP
Dirección IP del servidor DNS
Dirección IP de la puerta de enlace
Dirección de Broadcast
Máscara de subred
Tiempo máximo de asignación de IP (en caso de que ésta sea dinámica)

Direcciones IP mediante DHCP

Una de las principales características del servicio de DHCP es asignar las direcciones IP a cada host de la red. Esto se consigue mediante un intercambio de mensajes entre el cliente y el servidor.

El cliente se conecta a la red, y envía un paquete, llamado DHCPDiscovery , el cual se difunde para toda la red, y todos los nodos de la red lo reciben, pero el único que lo procesará, será el servidor DHCP, el resto de los nodos lo ignorarán. Este paquete se manda a toda la red, porque el cliente no tiene porque saber si hay servidor DHCP o no, y si lo hay, tampoco debe saber la dirección IP.

Cuando el Servidor recibe este paquete, éste le responde un DHCPOffer, el cual le sirve unos parámetros iniciales para la configuración.

Al recibir este último paquete, el cliente, emite otro paquete, el DHCPResquest, donde confirma que recibió los parámetros iniciales, y pide al DHCP una dirección IP libre.

El servidor recibe la petición del cliente, y el servidor le asigna toda la configuración de red restante mediante un DHCPACK. Y ya tendrá la configuración de red completada y lista para el uso.

Existen muchos otros paquetes de comunicación DHCP, pero los básicos son estos.

Configurabilidad del DHCP

En este servicio se pueden configurar varias opciones, pero la más configurable sin duda es la dirección IP.

Formas de asignar una IP

Asignación estática: El servidor asigna una dirección IP a una tarjeta de red, mediante su dirección MAC, que es única en el mundo.
Asignación automática: El servidor asigna una dirección IP a un equipo, y éste la mantiene hasta que no la libere el propio cliente.
Asignación dinámica: El servidor asigna las IP aleatoriamente, (entre un rango previamente asignado) y esta asignación tiene un tiempo límite para que la IP se libere y se asigne a otro equipo.

Alternativas al DHCP

Cuando este intercambio de paquetes no llega a buen puerto, el ordenador coge una IP alternativa, pero viene dada por el Sistema Operativo, y no por el servicio DHCP. Esto significa que la IP asignada no va a coincidir con la red.

La próxima semana comenzamos la práctica de Crear un servidor DHCP en Ubuntu, así que tenéis que tener esto claro para entenderlo mejor.

Gablabel, traduce textos desde tu escritorio fácilmente

2012-01-30T21:30:00.000+01:00

Si algo caracteriza a la Comunidad es la cantidad de proyectos que lleva a cabo. Encontramos un gran número de aplicaciones que ésta nos brinda, y las cuales nos facilitan la experiencia de usuario, además de tener a nuestra disposición el código, pudiendo mejorarlas si lo creemos oportuno, ya sea con ideas o directamente trabajando en él.

Uno de estos ejemplos es Gablabel, una aplicación que como su autor nos describe, es un pequeño cliente de escritorio para Google Translator, muy sencillo, ya que funciona como un pequeño navegador.

Su autor es Damián Nohales, desarrollador de software, y uno de los que autores gSharkDown, quien muy amablemente contactó con el blog para darnos a conocer esta simple, pero interesante aplicación. Este programa está desarrollado en el lenguaje de programación Vala y CMake.

Su autor ha alojado el código en Github, y nos comenta que por ahora, sólo pudo compilarlo y empaquetarlo para la arquitectura i386, no estando garantizado que funcione en otra distro que no sea Ubuntu, ya que se hace uso de la biblioteca para los indicadores de aplicaciones, aunque esto es algo que debe arreglar. Existen dos paquetes para las dos últimas versiones de Ubuntu, es decir, tanto para Natty como para Oneiric en su página de Descargas.

Su funcionamiento es el mismo que si estuviéramos usando Google Translate, pero desde nuestro escritorio, disponiendo de algún atajo de teclado como los de la captura, además de poder poner la aplicación a pantalla completa, y como si estuviéramos en el traductor de Google, elegir el idioma al que queramos traducir.

Desde el blog queremos felicitar a Damián, animarle a seguir desarrollando aplicaciones tan útiles, y agradecerle que las ponga a disposición de la Comunidad.

Aprovechando esta entrada, me gustaría comentar que estaremos encantados de publicar información sobre cualquier que programa estéis creando para GNU/Linux.

Saludos.

El Escritorio del Lector #61

2012-01-29T23:48:00.000+01:00

Nuestro visitante número 61, y no por ello menos importante, es Ariel Escobar, quien muy amablemente nos envía sus especifcaciones. Ariel ha optado por Gnome Shell en detrimento de Unity, algo por lo que muchos usuarios han optado, y que como ya hemos comentado en diversas ocasiones, demuestra el poder de elección del usuario.

S.O.: Ubuntu 11.10

Fondo de escitorio: Adwaita

Gnome-Shell: Adwaita

Iconos: Gnome

Cómo crear servicios web PHP

2012-01-25T12:53:00.000+01:00

Buenas, la semana pasada vimos como instalar un servidor LAMP en nuestro Ubuntu y las herramientas necesarias para desarrollar con PHP y MySQL. Esta semana nos ponemos manos a la obra y veremos como desarrollar un pequeño servicio web para poder utilizarlo más tarde desde una aplicación Android y nutrir nuestra aplicación con datos.

Los formatos más utilizados para compartir información mediante estos servicios web son XML (y otros derivados) y JSON. XML es un lenguaje de marcas muy similar al HTML, lo podéis ver normalmente en las fuentes RSS utilizadas para difundir listas de noticias. JSON es un formato ligero de intercambio de datos. Este último da mejores resultados en cuanto a rapidez y procesamiento, por lo tanto utilizaremos este, pero si queréis utilizar XML solamente deberéis cambiar el formato de salida y listo.

Nuestro servicio va a devolvernos una lista de libros, para ellos primero crearemos una base de datos. Abrimos phpMyAdmin para ello en un navegador escribimos http://localhost/phpmyadmin. Vamos a "Base de datos" y creamos una nueva base de datos, le llamaremos android, aparecerá en la lista de la parte izquierda. Pinchamos sobre ella y creamos una nueva tabla llamada libros con 3 columnas: id_libro, libro y isbn. Actualización: ponemos los nombres de las columnas en minúscula para no tener problemas a la hora de leerlo con el script PHP.

Para cada uno de los campos deberéis indicar de que tipo es, id_libro es un INT además como va a ser un identificador será PRIMARY y para que cada vez que insertemos un registro no nos tengamos que preocupar de calcular este dato marcamos la casilla AUTO INCREMENT.

Los campos libro y isbn son de tipo texto, tenemos VARCHAR el cual debemos indicar la longitud máxima, en nuestro caso pondremos 1.000 y 50 respectivamente. Existe otro tipo de dato para texto, TEXT, ideal cuando almacenamos grandes cantidades de texto, como por ejemplo el texto HTML de este artículo.

Una vez creada la tabla la seleccionáis e insertáis 4 ó 5 registros para que luego al crear el servicio podamos comprobar como funciona.

El siguiente paso es crear nuestro servicio para ello abrimos nuestro IDE BlueFish y dentro de la ruta /var/www/ creamos una carpeta android para nuestro servicio. El servicio constará de varios archivos los cuales os iré detallando que es lo que hace cada uno. Para crear cada uno de ellos haremos botón derecho del ratón sobre nuestra carpeta android, seleccionamos archivo nuevo y le damos el nombre correspondiente.

Empezamos con globals.php, el cual va a tener parámetros de configuración, en principio para poder acceder a la base de datos. Como podéis ver he creado una clase config y las propiedades son static, es decir, no necesito crear un objeto config para poder acceder a estas. Como veis PHP soporta programación orientada a objetos, aunque si queréis podéis utilizar programación estructurada.

<?php
class config{
 public static function getBBDDServer() {
  return 'localhost';
 }
 
 public static function getBBDDName(){
  return  'android'; 
 }
 
 public static function getBBDDUser(){
  return 'root'; 
 } 
 
 public static function getBBDDPwd(){
  return 'xxxxxx'; 
 }
}
?>

El siguiente archivo será dbmanager.php, este archivo nos ayudará a gestionar la base de datos y las consultas que hagamos a ella. Lo voy a hacer lo más básico posible para no complicar mucho el ejemplo. Vuelvo a crear una clase dbmanager con el método executeQuery, al que le pasamos una consulta, esta se ejecuta y nos devuelve el resultado.

include_onde

Destacar la instrucción include_once para referenciar nuestro archivo de configuración. Existe también la instrucción include, la diferencia entre ellas es que la primera solo incluye una vez el mismo archivo, lo cual puede dar problemas si se incluye más de una vez.

Para poder utilizar las propiedades de esta clase lo hacemos con el nombre de la clase seguido de :: y el nombre de la propiedad o método.

<?php
include_once('globals.php');

class dbmanager{
 
 public function executeQuery($sql){
  $con = mysql_connect(config::getBBDDServer(), config::getBBDDUser(), config::getBBDDPwd());
  if (!$con)
    {
     die('Could not connect: ' . mysql_error());
    }
  
  mysql_select_db(config::getBBDDName(), $con);
  
  $result = mysql_query($sql);
  
  mysql_close($con);
  return $result;
 }
}
?>

El siguiente archivo es libros.php, otra vez hago los include de los archivos necesarios y creo una clase libros con dos métodos. El primero de ellos getLibros, crea un objeto dbmanager y ejecuta la consulta que hemos construido en el mismo método. Como veis es private por que lo vamos a utilizar únicamente dentro de la clase.

El segundo método getJSONLibros es publico y se encarga de obtener los datos con el método anterior y almacenar el resultado en la variable $result, luego la recorre y construye la estructura JSON con cada uno de sus items, y por ultimo devuelve la variable $json.

Variables PHP

Como veis las variables en PHP se declaran con un $ siempre delante y para utilizar metodos de un objeto que hemos instanciado sería clase->metodo. Si el método está en la misma clase seria $this->metodo.

<?php
include_once('globals.php');
include_once('dbmanager.php');

class libros{

      private function getLibros(){
 $sql = "SELECT l.* ";
 $sql .= " FROM libros AS l ";
 $db = new dbmanager();
 return $db->executeQuery($sql);
     }

     public function getJSONLibros(){
        $json = "";
 $i = 0; 
 $result = $this->getLibros();
 $json .= " { \"libros\" : [ ";

 while($row = mysql_fetch_array($result)){
    if($i > 0)
     $json .= ",";
 
    $json .= " { \"id\" : ".$row['id_libro'].", \"libro\": \"".$row['libro']."\", \"isbn\": \"".$row['isbn']."\" ";    
    $json .= "} ";   
    $i++;
   }  
  
 $json .= " ] ";
   $json .= " } ";  
   return $json; 
    }
}

El último archivo es al que llamaremos para obtener el resultado de nuestro servicio, lo llamaremos service.libros.php. Este archivo es muy simple, únicamente se hace el include necesario, instancia la clase libros e imprimimos el resultado del método getJSONLibros.

<?php
include_once('libros.php');

$libros = new libros();
echo $libros->getJSONLibros();
?>

Por último probamos en el navegador este servicio con la url http://localhost/android/service.libros.php. Debería aparecer el JSON correspondiente, si queréis comprobar que está todo correcto podéis hacerlo en alguna de las webs que lo hacen online, http://jsonlint.com/ por ejemplo.

Ahora ya tenemos listo nuestro servicio listo para poder leerlo con cualquier cliente, en nuestro caso haremos un cliente en Android la semana que viene que lea este JSON y nos lo muestre.

Nuestras amigas las direcciones IP

2012-01-24T14:00:00.028+01:00

Tras haber terminado con éxito el servidor DNS. Comenzamos una nueva serie de artículos, con la finalidad de instalar un servidor DHCP. Pero para poder conseguir esto, primero debemos tener unos conceptos previos. Un servidor DHCP sirve para asignar de manera automática las IPs. En el siguiente artículo entraremos en detalle en los DHCP. Hoy nos tocan las direcciones IP.

¿Qué significa IP y para qué sirve?

IP son las siglas inglesas de Internet Protocol, lo cual significa que es el protocolo que sigue Internet para realizar sus comunicaciones, y en general la mayor parte de las redes informáticas del mundo.

Este protocolo se basa en asignar a cada elemento de la red (ordenador, router, impresora de red, móvil, página web...) una dirección IP compuesta por una serie de números y puntos, y así que el dispositivo esté localizable en la red.

Hoy en día existe una mejora de la IPv4 (la más común a día de hoy), que es la IPv6, que permite tener muchos más dispositivos, y además se agotaron las IPv4 públicas. Nos centraremos en la IPv4 porque es la que nos interesa para los posteriores artículos.

Dirección IP

La direcciónIPv4 (A partir de ahora simplemente IP), es básicamente un número binario formado por 32 bits (32 unos y ceros seguidos) que identifica de forma lógica y estructurada un dispositivo o interfaz en una red de tipo TCP/IP. Se divide en 4 octetos de código binario separados por puntos.

Una dirección IP está dividida en dos, una parte que identifica a la red a la cual está conectada, y la otra identifica el dispositivo de ésa red a la cual pertenece.

Ejemplo:

192.168.0.100

RED   11000000 . 10101000 . 00000000. 01100100 HOST

Esta dirección IP, por sí sola, no nos dice nada. Pero cuando terminéis este artículo, comprenderéis que la parte "192.168.0" identifica a la red, y el resto "100" indica que es el dispositivo 100 de la red 192.168.0. Ahora veremos porqué.

Tipos

La finalidad de este protocolo es identificar y diferenciar unos dispositivos de otros y además unas redes de otras.

Por ello existen varias clases de IP:

Clase A: El primer octeto identifica la red, y los otros tres, el dispositivo. Este tipo de red se utiliza para poder tener muchos dispositivos por red.

En este caso permite por cada red (primer octeto), más de 16 millones de dispositivos, pero sólo 128 redes diferentes.

Se diferencian de una manera básica, estas redes tienen un rango del primer octeto de 10.X.X.X hasta 126.X.X.X.

Clase B: Los dos primeros octetos identifican la red, y los otros 2 los dispositivos. Es un tipo de red equilibrada, permite bastantes redes (16.384), y bastantes host o dispositivos (65.534) por cada red.

Sus rangos son desde: 128.0.X.X hasta 191.255.X.X.

Clase C: Los tres primeros octetos identifican la red, y el último identifica el host. Permite más de dos millones de redes y 254 host por cada red.

El rango para reconocerla es desde 192.0.0.X hasta 223.255.255.X

También se pueden clasificar en públicas o privadas.

Las IP públicas, son las que se venden para poder tener una página web, un servidor o cualquier dispositivo accesible en la red de redes (Internet).

También son las que usamos para que tengamos acceso a Internet, cada proveedor (ISP) de internet nos proporciona una.

Las IP privadas, son las que no son públicas, y se utilizan para crear redes locales, para que no creen conflictos con las públicas. Estas están reservadas por clases:

Clase A: 10.0.0.0 hasta 10.255.255.255

Clase B: 172.16.0.0 hasta 172.31.255.255

Clase C: 192.168.0.0 hasta 192.168.255.255

Las direcciones IP se pueden clasificar según su configuración.

IP fija

Nosotros decidimos nuestra IP (local), definiéndola en la configuración del sistema operativo. En lo referente a Ubuntu podemos cambiarla siguiendo un artículo de mi compañero.

IP dinámica

Un router o un servidor de DHCP asigna una IP a cualquier dispositivo que se conecte a la red. Éste envía unos paquetes por la red y el servidor DHCP le responde con la IP que debe tomar.

Máscaras de Subred

Las máscaras de subred sirven para dividir la parte de red en una dirección IP de la de host. Son también una serie de 32 bits separados en octetos. Pero la diferencia es que la parte de red la indican los unos, y la parte de host la indican los ceros.

Ejemplo

Dirección IP:

Clase C:

192.168.0.100

11000000 . 10101000 . 00000000. 01100100

Máscara de subred:

255.255.255.0

11111111 . 11111111 . 11111111. 00000000

También puedes crear subredes cambiando la máscara, indicando hasta dónde es la parte de red, y dónde es el host.

Y hasta aquí este simple artículo sobre las direcciones IP. Espero que os ayude a entender el entramado de las redes informáticas. Cualquier duda, escribirla en los comentarios e intentaré ayudaros.

Un saludo.

El Escritorio del Lector #60

2012-01-22T23:59:00.001+01:00

Como buen domingo que es, y recuperando la normalidad en lo referente a "El Escritorio del Lector", volvemos con el Escritorio número 60. No me cansaré de repetir que es una sección que me ha sorprendido muy gratamente, ya que vosotr@s sois los que la hacéis seguir enviando vuestras capturas y características. Es muy gratificante que os impliquéis con el blog, así que desde aquí os agradecemos que sigáis participando y comentando.

Nuestro visitante número 60 es Lucas, compañero blogger que sigo tanto en su cuenta Twitter como en su blog, y quien nos envía un Escritorio bastante simplificado y elegante, con un fondo de pantalla muy agradable a la vista, con la distribución ArchBang.

SO: ArchBang

Wallpaper, se puede bajar desde este link

Gestor de ventanas: OpenBox

Tema: Mist

Tema de iconos: Faenza

Aplicaciones: Tint, Conky, WBar y Xcompmgr para efectos de composición.

Prepara tu entorno de desarrollo PHP en Ubuntu: LAMP, phpMyAdmin y BlueFish

2012-01-18T12:42:00.004+01:00

Buenas, normalmente todas las semanas trato algún tema sobre Android, pero esta semana voy a cambiar un poco de tema, pero tengo mis razones. Esta semana voy a hablaros de como preparar vuestro Ubuntu para poder desarrollar con PHP. La razón es que a continuación os hablaré de como realizar un servicio que se comunicará con nuestras aplicaciones Android y nutrirlas de más información.

Para los que no lo sepáis, LAMP viene siendo la abreviatura de: Linux + Apache + MySQL + PHP. Este proporciona un servidor web Apache, un servidor de base de datos MySQL y toda la potencia de PHP para ejecutar nuestros sitios web.

La instalación es muy sencilla, en un terminal debemos ejecutar lo siguiente:

sudo apt-get install tasksel

Esto lo que va a hacer es instalar el mismo paquete que utiliza Synaptic internamente, esto es porque en las nuevas versiones de Ubuntu desde la 10.10 no existe este paquete y debemos instalarlo de forma manual.

Una vez lista la instalación, ejecutamos la herramienta tasksel.

sudo tasksel

Aparecerá una ventana para seleccionar que software queremos instalar, nosotros en nuestro caso vamos a seleccionar LAMP Server (seleccionamos con la barra espaciadora). Empezamos la instalación y en un momento determinado nos pedirá una contraseña para el usuario "root" administrador de la base de datos MySQL, asignáis la que vosotros querrais y continuamos con la instalación.
Importante: si no estáis seguros para que sirve el resto de cosas no las quiteis podeis llegar a desinstalar componentes vitales para vuestro sistema. Muchas gracias a Alejandro Abarca por el aporte.

Una vez listo reiniciamos apache desde la consola.

sudo /etc/init.d/apache2  restart

Para comprobar que todo ha ido bien abrimos un navegador y escribimos en la barra de direcciones "http://localhost", está es la dirección de nuestra propia maquina, podemos acceder también mediante "http://127.0.0.1" o con la IP que tengamos asignada en nuestra red de área local. En cualquier caso, el resultado va a ser el mismo una página web en blanco con el texto "It works!", es la página por defecto que nos muestra Apache.

El directorio raíz donde tienen que estar ubicados nuestros sitios web es /var/www/. Nuestro usuario no tendrá permisos para modificar en este directorio por lo que es recomendable que nos demos algún privilegio para facilitarnos el desarrollo para ejecutamos en un terminal lo siguiente:

~$ cd /var/www/
/var/www$  sudo chown -R usuario .

Con esto último comando estamos haciéndonos propietarios de esta carpeta y todas las que contiene(no olvidéis incluir el punto que va al final). Como recomendación yo suelo tener un enlace a esta carpeta en mi carpeta personal por comodidad y rapidez a la hora de acceder a ella.

Si queréis comprobar y ver la configuración de nuestro servidor podeis crear en /var/www/ un archivo llamado info.php con la siguiente línea:

<?php phpinfo(); ?>

Si ejecutamos esto en nuestro navegador mediante http://localhost/info.php nos mostrará una página con la configuración de nuestro servidor.

Ahora que ya tenemos instalado el servidor, nos hacen falta las herramientas para desarrollar. Lo primero a instalar es una herramienta para gestionar nuestra base de datos, lo más común es phpMyAdmin. Es una herramienta gestionada via web y os recomiendo que utiliceis esta porque los proveedores de sitios web son la que incluyen para gestionar los sitios, de esta forma a la hora de gestionar vuestro sitio web ya estaréis familiarizados con esta herramienta.

Para instalarla ejecutamos en el terminal:

sudo apt-get install phpmyadmin

Y una vez instalada accedemos escribiendo en el navegador: http://localhost/phpmyadmin. Existen otras herramientas como por ejemplo la que nos proporciona MySQL: MySQL Query Browser que también es bastante buena, pero nosotros vamos a centrarnos en phpMyAdmin.

La última pieza para tener completo nuestro entorno de desarrollo es un IDE para desarrollar en PHP. Existen varias alternativas, de las cuales yo me quedo con dos: BlueFish por sencillez y Eclipse + Plugin PDT porque es bastante completo y unifica en un solo IDE la mayoría de los lenguajes con los que personalmente trabajo.

Debido a que el desarrollo en PHP va a ser muy sencillo veremos como instalar BlueFish. Este se puede instalar desde el centro de software de Ubuntu o mediante el comando:

sudo apt-get install bluefish

Y con este último paso terminado ya estamos preparados para empezar a desarrollar con PHP y MySQL. La semana que viene veremos como crear un pequeño servicio que posteriormente utilizaremos en una aplicación Android.

Guía para crear un Servidor DNS en Ubuntu Parte 3 (Última)

2012-01-17T16:38:00.002+01:00

Tras varias semanas aparcado, y yo de vacaciones, retomo la última entrega que os tenía prometida, ya que, por diversos motivos no pude la semana pasada, volvemos con el tema de los DNS, para ya por fin finalizar este tema. Recordamos que si tenéis algunas dudas, explicarlas mediante los comentarios, o la pestaña superior de contactos.

Os dejo los enlaces anteriores por si necesitáis repasarlos antes de continuar con esta guía y dar por terminada la instalación y configuración del servidor:

Introducción a los DNS. ¿Qué son?¿Para qué sirven?
Instalación del DNS en Ubuntu (Parte 1)
Configuración del DNS en Ubuntu (Parte 2)

Si hacemos un poco de memoria, ya sabemos cómo crear zonas en nuestro servidor, tanto directas como inversas. También sabemos ya cómo crear registros en ambas, y dar de alta nodos de nuestra red.

¿Qué vamos a aprender hoy?

Reenvío de peticiones de servidor.
Crear registros de alias (CNAME).
Comprobar errores en el servidor.
Crear una zona subordinada.
Humildes consejos.

Reenvío de peticiones del servidor.

Hasta este momento, nuestro servidor DNS, sólo resuelve los nombres que estén registrados en él. Todo lo que esté fuera de esta área es invisible para el servidor. Esto se arregla simplemente reenviando a otro servidor de nombres aquellas peticiones que el nuestro no encuentre, ya sea un servidor de otra red local, u otro de Internet, como uno público.

Debemos dirigirnos a la página principal del BIND9 de webmin, y una vez allí entraremos en la sección de "Reenviadores y Transferencias"

Nos aparecerán todas las opciones que tenemos para poder reenviar las peticiones que no tengan un destinatario concreto. Lo único que debemos hacer es poner la dirección IP en la cual se encuentra el servidor de red local, o de Internet.

Nota:

Los reenvíos de peticiones, tendrán prioridad según la plaza que ocupen en esta lista que nos muestran. En la imagen: primero buscará en el servidor 192.168.2.150 y tras eso buscará en el servidor 8.8.8.8 y finalmente en el 8.8.4.4

Yo utilizo esos dos servidores, porque son unos DNS de Google, los cuales tienen todas las direcciones públicas de Internet. Pero esos servidores sólo nos servirán cuando queramos resolver dominios de fuera de la red local. Si queremos que resuelvan dominios de otra red privada, debemos reenviar las peticiones al otro servidor local, y que el segundo acepte esas peticiones extra. Finalmente le damos a salvar, y si es necesario reiniciaremos el servicio.

Crear registros Alias (CNAME)

Hasta este momento, para encontrar un ordenador, teníamos que escribir nuestra dirección tal que así (dependiendo de los registros creados):

iscario.nosinmiubuntu.

Con el punto al final, y esto es más cómodo que la IP que era:

192.168.1.101

Pero vamos a darle una vuelta más de tuerca, cuando necesitamos que un equipo esté visible por varios nombres, ya que quizás el trabajador "iscario" se encuentre además en la oficina 1, podemos referirnos a él como cualquiera de los dos nombres mediante este tipo de registros.

Para ello usamos los registros CNAME o alias, los cuales sirven para crear, como su nombre indica, un alias para poder localizar con varios nombres un mismo recurso de red.

Nos dirigimos la página principal de BIND9, y entramos en nuestra zona primaria (en nuestro caso "nosinmiubuntu") y una vez allí, entraremos en la sección de "Alias de nombre".

Una vez dentro debemos escribir el alias que le queramos poner, y en el cuadro de abajo la dirección completa del nodo que queramos crear un alias, es importante que le pongamos el punto final, fíjate bien. Como es lógico, no podemos repetir el nombre original, debemos escoger otro diferente. Finalmente le damos a crear, y nos aparecerá una lista con todos los que hemos creado.

Comprobar errores en el servidor.

Webmin tiene una opción muy simple que comprueba de forma automática si tiene errores los archivos de configuración. Para ello, vamos a la pantalla principal y entramos en la sección "Check BIND Config".

Al acceder a esta sección, webmin comprobará si tiene algún error (no es muy común utilizando webmin, pero puede ocurrir) y si es así, lo mostrará. En mi caso no hay ningún error, por lo cual me muestra un mensaje, notificándome que no tengo ningún error en el archivo de configuración o en las zonas a las que hace referencia.

Crear una zona subordinada.

Las zonas subordinadas sirven para compartir información de un servidor principal, y así poder funcionar como backup o como servidor para balancear la carga.

Para crear una zona así, debemos ir a la página principal de BIND9, en webmin, y una vez allí debemos crear una zona, pero en este caso subordinada.

Entonces, se nos abre la pestaña de creación de zona, en la cual debemos de escribir el nombre de la zona, y asignarle las IPs del servidor del cual debe coger toda la información.

Nota:

Recuerda, que debes poner una IP de la misma red que el servidor principal, para poder transferir esa información. Otra opción es tener correctamente configurado el router. Pero la clave es que el equipo de la zona subordinada tenga acceso al servidor principal.

Finalmente, le damos a crear, y nos aparecerá una vista, como si fuera una zona maestra, podremos consultar los datos del DNS principal, pero no podemos modificarlos, ya que sólo es una zona de apoyo o de copia de seguridad.

Humildes Consejos

Una gran parte de las veces que no funciona algo, debemos parar el servicio BIND9 y volverlo a arrancar. De hecho deberíamos hacerlo en cada modificación que hacemos.
Es muy importante la configuración de red. Si algo está mal configurado, no funcionará y no sabrás porque.
Para que el servidor esté visible en Internet, debemos contratar una IP fija en nuestro ISP (Compañia de ADSL) y configurarlo con las IPs que nos den.
Hay más cosas que no he explicado aquí, porque son más avanzadas, o yo no las veo imprescindibles para el funcionamiento del servidor. Pero recuerda que si usas una máquina virtual, puedes trastear todo lo que quieras, sin estropear la configuración de tu equipo.

Nada más desde aquí. Un saludo, gracias por la paciencia, y espero me disculpéis por la tardanza. Hasta la próxima.

Asturix 4, una distribución muy interesante

2012-01-16T18:07:00.002+01:00

Dentro del universo GNU/Linux existen multitud de distribuciones, algo que para unas personas puede suponer un problema, y para otras algo maravilloso. En el blog nos decamentamos por la segunda opción, ya que tener esta diversidad ayuda a la libertad de elección del usuario y a enriquecer la Comunidad con posibilidades sorprendentes, que nos ayudan a disponer de cualquier herramienta o sistema que podamos imaginar.

Una de estas maravillosas opciones de las que podemos disfrutar es Asturix, distribución basada en Ubuntu, y que nació en 2008 como una idea de Luis Iván Cuende. Nació como una distribución linux regional, pero se ha convertido en una de las más reconocidas a nivel internacional, siendo instalada en más de 20 paises, y haciéndose con múltiples premios y nominaciones, como 2 nominaciones en ediciones especiales de Campus Party (Europa y Granada), desarrollada por el proyecto Asturix.

Gracias a Ricardo López, su delegado de comunicaciones, nos enteramos de la salida de Asturix 4, la cual viene con características tan suculentas como:

Nueva experiencia de usuario. Hemos desarrollado un nuevo entorno de escritorio para mejorar la usabilidad, productividad y ayudarte a permacener concentrado, desarrollado con tecnologías web (como HTML5 o CSS3).

Tiene la mayor paleta de color del mundo por defecto. Gracias a nuestros colaboradores de GiveLifeCS puedes disfrutar de más de 5000 colores cuando estés usando GIMP, Inkscape o cualquier otra aplicación.

Previsualizaciones de todo. Ahora ya no tienes que abrir LibreOffice para ver un documento. Con la barra espaciadora podrás previsualizar cualquier tipo de archivo.

Las redes sociales y de microblogging están integradas, por lo que tendrás fácil acceso a Twitter, Facebook o Identi.ca

Asturix Bridge te permite añadir, modificar y ejecutar aplicaciones web como aplicaciones nativas.

Chromium, LibreOffice, GIMP, Clementine, VLC… tiene todas las aplicaciones que desearás encontrar. Además puedes instalar miles de aplicaciones desde el Software Center.

Música libre y gratuita gracias a Jamendo, integrado en el reproductor Clementine. ¡Es legal!.

Impresionante gestión de escritorios con las teclas Super+S.

Decir que a nivel de requerimientos, como ocurre con la mayoría de distribucionesGNU/Linux, no necesitas equipos muy potentes, teniendo como Requerimientos mínimos 512 MB de RAM y 5 GB de HD, y como Recomendados 1GB de RAM y 10 GB de HD.

Sólo nos queda felicitar a todo el equipo de Asturix por el lanzamiento de esta nueva versión, y desearle toda la suerte del mundo, además de, por supuesto, recomendar que probéis este Sistema Operativo tan interesante.

Saludos.

El Escritorio del Lector #59

2012-01-15T20:57:00.000+01:00

Como ya dijimos ayer esta semana hay doble ración de "El Escritorio del Lector". No me cansaré de repetir que es una sección que me ha sorprendido muy gratamente, ya que vosotr@s sois los que la hacéis seguir enviando vuestras capturas y características. Es muy gratificante que os impliquéis con el blog, así que desde aquí os agradecemos que sigáis participando y comentando.

En la segunda ración de la semana el portagonista es Esteban Ramírez, quien nos muestra un área de trabajo basado en Ubuntu con Gnome Shell como entorno de escritorio, lo que nos demuestra que aunque Ubuntu venga con Unity, y existan quejas al respecto, podemos modificar a nuestro antojo cualquier distribución.

S.O.: Ubuntu 11.10

Tema: Zukini

Iconos: Faenza Cupertino

Fondo de escritorio: Derp

Ademas de algunas extensiones de Gnome Shell

El Escritorio del Lector #58

2012-01-14T19:48:00.001+01:00

Como comentábamos la semana pasada, tuvimos un pequeño parón en lo referente a publicaciones debido a las vacaciones navideñas. Por ello, durante esta semana vamos a publicar "El Escritorio del Lector" tanto Sábado como Domingo, para así cumplir lo prometido a nuestros lectores.

Me gustaría recordar que en esta sección, de la que estoy particularmente orgulloso por la gran aceptación que le habéis dado, aquí el protagonista puedes ser tú, tan sólo tienes que querer mostrar cómo es el área de trabajo donde te manejas, para que el resto conozcamos nuevos paquetes de iconos, temas, etc. Una muy buena forma de compartir vuestro trabajo a la hora de dejar lo más cómodo posible el Escritorio.

Este atípico día para la sección está dedicado a V. Hugo Btt, quien en vez de enviarnos un único Escritorio, nos envía dos, el mtivo no es otro que haberse cambiado de distribución, de Ubuntu a Linux Mint, algo que como bien sabréis aparentemente ha hecho mucha gente debido a Unity. El autor nos ha pedido que pongamos a vuestra disposición su correo por si tenéis alguna duda vhugo.btt@gmail.com

S. O.: Ubuntu 11.04 en LiveUSB

Tema: Ambiance modificado, color de selecciones #772953.

Iconos: Awoken 2.3

En pantalla: Netbook Launcher Efl

S.O.: Linux Mint 11 "Katya"

Saludos.

Día del Usuario Ubuntu, aprende de la Comunidad

2012-01-13T12:00:00.012+01:00

Si hay algo que caracteriza a GNU/Linux en general, y a Ubuntu en concreto es la gran Comunidad que hay detrás. Gracias a ésta disponemos de una gran cantidad de canales con los que obtener información, los cuales sirven de ayuda tanto a la gente que está empezando como a los más expertos.

Uno de estos canales es Ubuntu Classrom, en el cual se crean una serie de charlas en eventos del tipo Ubuntu Open Week. Como gran parte de esta información está en inglés, disponemos de Classroom_ES, en la cual se organizan eventos paralelos en la lengua de Cervantes, gracias a gente como Sergio Meneses o Marcos Costales, además de, por supuesto, los instructores que impartirán las charlas.

En esta ocasión disponemos de la versión en español del Día del Usuario Ubuntu, que como nos describen en su correspondiente wiki, nos es otra cosa que un conjunto de charlas que se van a dar en el correr de un día para que los nuevos usuarios de Ubuntu, con conocimientos básicos e intermedios puedan aprender cosas como:

Cómo instalar Ubuntu.

Encontrar programas equivalentes en Ubuntu.

Cómo obtener ayuda.

Aprender cosas básicas para utilizar Ubuntu.

Aprender como integrarse y colaborar con la comunidad.

Para acceder a las sesiones simplemente tendrás que entrar en los canales #ubuntu-charlas y #ubuntu-charlas-chat de los servidores IRC de freenode irc.freenode.net o seguir el siguiente enlace, donde deberás ingresar un nombre que te identifique (en Nickname) y dar clic en conectar (Connect).

Si quieres saber el horario de las charlas para tu ciudad, da clic en el enlace con la hora UTC, este te mostrará la hora local en tu ciudad.

Instructor	Tema	Horario
SergioMeneses	Apertura de la jornada	17:30 UTC
mimecar	Copias de seguridad: Grsync y Clonezilla	18:00 UTC
costales	Seguridad básica: Cortafuegos Gufw	19:00 UTC
primicachero	Equivalencia programas Windows/Ubuntu	19:30 UTC
LinaPorras	Programas de Mensajería Instantánea en Ubuntu	20:00 UTC
chilicuil	Corrección de bugs I	21:00 UTC
chilicuil	Corrección de bugs II	22:00 UTC

Como siempre que hay este tipo de eventos, desde el blog os animamos a asistir tanto si eres un usuario experto como novato, ya que pueden resultar bastante interesantes, pudiendo interactuar con otros ubunteros que tienen la misma filosofía de compartir.

Saludos.

Arranque múltiple con dispositivos USB

2012-01-12T00:00:00.011+01:00

Cada día que pasa, los dispositivos de almacenamiento USB adquieren más fama, en detrimento de los soportes ópticos como CDs y DVDs; varios son los motivos: mayor velocidad de transferencia de datos, tamaño reducido, ..., y la aparición de equipos informáticos que ya no disponen de unidades ópticas, como puede ser un simple Netbook. Para la instalación de cualquier sistema operativo en uno de estos equipos, lo más habitual es hacer uso de un dispositivo USB preparado para tal fin. Últimamente, y con la proliferación de Live CDs de un buen número de distribuciones de GNU/Linux, también se utilizan dispositivos USB para probar éstas sin alterar los sistemas. Por otro lado, existen multitud de herramientas de diagnóstico, particionado y reparación que pueden ser utilizadas mediante un USB de arranque.

En esta entrada, vamos a ver cómo preparar un dispositivo USB de 2 GB para que nos permita arrancar dos versiones distintas de Ubuntu, sin necesidad de instalación alguna, simplemente a partir de sus imágenes ISO. Para ello, utilizaremos el gestor de arranque GRUB 2. Los pasos a seguir son los siguientes:

1. Instalamos GRUB 2 en el sistema:

sudo apt-get install grub2

2. Conectamos el USB y comprobamos cuál es su punto de montaje y su nombre de dispositivo:

mount | grep /media

En la siguiente imagen aparece subrayado en amarillo el nombre de dispositivo (/dev/sdb) y en azul el punto de montaje (/media/6ABE-30DD):

3. Instalamos GRUB 2 en el USB utilizando los datos obtenidos anteriormente:

sudo grub-install --root-directory=/media/6ABE-30DD /dev/sdb --force

Observamos que en el USB se ha creado un directorio boot :

4. Copiamos al USB las imágenes ISO que vayamos a utilizar (podemos meter cada una de ellas en un directorio o bien dejarlas en el directorio raíz del dispositivo, como hemos hecho en este caso):

5. Entramos en el directorio boot/grub del USB, creamos un archivo vacío y lo renombramos como grub.cfg :

6. Editamos grub.cfg y le añadimos una entrada (menuentry) por cada ISO que queramos incluir en el menú de arranque; en este punto es imprescindible conocer la ruta completa tanto del kernel (vmlinuz) como del disco RAM inicial (initrd), pues ambos pueden variar en función de la distribución elegida:

* El parámetro boot, que figura inmediatamente después de /casper/vmlinuz, hace referencia al directorio donde se encuentra el kernel de la ISO; en este caso, boot=casper, pues vmlinuz está dentro del directorio casper.

Guardamos grub.cfg y ya tenemos listo nuestro USB con arranque múltiple. Podemos añadir las imágenes ISO que queramos, basta con crear una menuentry para cada ISO. El límite está en la capacidad de almacenamiento del dispositivo USB.

Saludos.

Cómo descargar imagenes en Android

2012-01-11T14:27:00.001+01:00

Buenas, la semana pasada vimos como ponerle bordes redondeados a una imagen y hacerla cuadrada, para el ejemplo de utilización de nuestro método utilizamos una imagen ubicada como recurso en la aplicación, y nos quedo pendiente ver como obtener las imágenes desde un repositorio en internet. Esta semana veremos como hacer esto.

Lo primero que debéis hacer antes de nada es darle permisos de internet a nuestra aplicación, esto lo hemos visto en artículos anteriores.

Ahora lo mejor es llevar los métodos que vamos a ver a una clase, yo me voy a crear una llamada ImageManager. Tambien veremos como hacer todo este proceso en un hilo de ejecución diferente del de la aplicación, de esta forma las imagenes se irán descargando y el resto de la aplicación seguirá ejecutandose. Veamos el contructor y las variables que hemos de definir.

private final Map<String, Drawable> drawableMap;

final Context context;

public ImageManager(Context c) {  
     drawableMap = new HashMap<String, Drawable>();
    context = c;
}

Hasta aquí todo es bastante sencillo, estamos definiendo un par de variables en la clase e inicializándolas en el constructor de la clase. Veamos ahora el método principal de la clase, el que se encargará de descargar la imagen.

public void fetchDrawableOnThread(final String urlString, final ImageView imageView) {
     
    
    final Handler handler = new Handler() {
 @Override
 public void handleMessage(Message message) {
       imageView.setImageDrawable((Drawable) message.obj);
 }
    };
 
    Thread thread = new Thread() {
  @Override
  public void run() {
      try{
          Drawable drawable = fetchDrawable(urlString);
          Message message = handler.obtainMessage(1, drawable);
          handler.sendMessage(message);
      } catch(Exception e){
          imageView.setVisibility(View.GONE);
      }
  }
    };
    thread.start(); 
}

Como veis el método no es muy extenso. Primero definimos nuestro handler que será el encargado de procesar los mensajes del nuevo hilo de ejecución cuando nuestra imagen se haya descargado y asignársela al ImageView.

Después definimos el hilo(thread), para el cual en un objeto Drawable descargaremos y convertiremos nuestra imagen con el método fetchDrawable, después asociamos el objeto drawable con nuestro handler y iniciamos el nuevo hilo con el método start.

 public Drawable fetchDrawable(String urlString) {
        if (drawableMap.containsKey(urlString)) {
            return drawableMap.get(urlString);
        }

        try {
            InputStream is = fetch(urlString);
            Drawable drawable = Drawable.createFromStream(is, "src"+urlString);
            if (drawable != null) {
                drawableMap.put(urlString, drawable);
                return drawable;  
            } else {
             return null;
            }         
        } catch (MalformedURLException e) {
           return null;
        } catch (IOException e) {
           return null;
        } catch (Exception e){
           return null;
        }
    }

El método fetchDrawable que os he puesto aquí se encarga de verificar si la URL que hemos indicado ya existe en drawableMap, el cual almacena pares llave/valor, y devuelve el drawable correspondiente en caso afirmativo.

Si no teniamos la imagen la descargamos con el método fetch el cuál nos devuelve un objeto de tipo InputStream a partir del cual crearemos el objeto drawable con el método estático createFromStream y lo almacenamos en drawableMap.

private InputStream fetch(String strURL) throws IOException{
 InputStream inputStream = null;
 URL url = new URL(strURL);
 URLConnection conn = url.openConnection();
 
 try{
  HttpURLConnection httpConn = (HttpURLConnection)conn;
  httpConn.setRequestMethod("GET");
  httpConn.connect();
 
  if (httpConn.getResponseCode() == HttpURLConnection.HTTP_OK) {
   inputStream = httpConn.getInputStream();
  }
 }  catch (Exception ex){}
 return inputStream;
}

El método fetch se encarga de abrir una conexión HTTP mediante el método GET, obtener una respuesta y devolverla en un objeto de tipo InputStream.

Hasta aquí el código de nuestra clase, ahora solamente queda utilizarla en nuestra activity, podeis recolectar cualquier imagen de internet en cualquier página, por ejemplo la nuestra haciendo botón derecho y copiando la dirección, y con unos cuantos ImageView vereis como las imagenes se van descargando. Mientras tanto al descargarse en un hilo diferente podeis realizar otras acciones en vuestra aplicación. Os pongo un pequeño ejemplo de uso.

ImageView imageView = (ImageView) findViewById(R.id.image);
ImageManager imageManager = new ImageManager(this);
imageManager.fetchDrawableOnThread("http://.....", imageView);

Si queréis que estas imágenes tengan una permanencia más duradera en vuestra aplicación podéis guardarlas en la tarjeta SD del dispositivo.

El Escritorio del Lector #57

2012-01-08T23:30:00.000+01:00

Después de un pequeño parón en lo referente a publicaciones debido a las vacaciones navideñas, hoy volvemos a retomar la rutina de la mejor manera posible, con vuestra sección, que no es otra que "El Escritorio del Lector". Como bien sabéis, aquí el protagonista puedes ser tú, tan sólo tienes que querer mostrar cómo es el área de trabajo donde se maneja, para que el resto conozcamos nuevos paquetes de iconos, temas, etc. Una muy buena forma de compartir vuestro trabajo a la hora de dejar lo más cómodo posible el Escritorio.

Para inaugurar la sección este año nos visita Christian Gaitan, quien nos comenta que usa Xfce en Ubuntu, porque Unity consume muchos recursos, al igual que Gnome Shell. en mi Notebook. Además, nos describe cómo consiguió su Escritorio:

"Desactivé los paneles de Xfce y sólo uso un dock a modo de lanzador, que se oculta automáticamente, y desde donde gestiono las ventanas. Además de un segundo pequeño dock con Gnome-Do, que se encuentra en el lado superior derecho con los indicadores de sistema que siempre se mantiene visible.. El navegador de archivos es Nautilus, y los efectos son de compiz con el icono de compiz fusion. Así tengo un escritorio bastante ligero y bonito."

S.O.: Ubuntu 11.10

Entorno de escritorio: Xfce

Tema: Adwaita

Iconos: Faenza

Cursores: Comix Cursor Blue

Fondo: Max Beat

Dock: Avant Window Navigator

Saludos.

Cómo redondear y encuadrar imagenes con Android

2012-01-04T11:54:00.003+01:00

Buenas, cómo todos los miercoles vuelvo por nosinmiubuntu. Durante estas últimas semanas he ido publicando algunos trucos o técnicas que no se suelen encontrar en los manuales al uso de Android, sino que se encuentran a base de buscar y buscar en foros. Hoy voy a seguir con esa tónica y voy a hablaros de como redondear los bordes de una imagen y encuadrarla.

Bien, la cosa es muy sencilla, cogemos una imagen ya sea en nuestra aplicación, en la tarjeta SD o descargándola, redondeamos los bordes de esta para que no tenga un aspecto tan frío con esos bordes cuadrados y se la mostramos al usuario por pantalla.

public static Bitmap getRoundedCornerBitmap( Drawable drawable, boolean square) {
     int width = 0;
     int height = 0;
     
     Bitmap bitmap = ((BitmapDrawable) drawable).getBitmap() ;
     
     if(square){
      if(bitmap.getWidth() < bitmap.getHeight()){
       width = bitmap.getWidth();
       height = bitmap.getWidth();
      } else {
       width = bitmap.getHeight();
          height = bitmap.getHeight();
      }
     } else {
      height = bitmap.getHeight();
      width = bitmap.getWidth();
     }
     
        Bitmap output = Bitmap.createBitmap(width, height, Config.ARGB_8888);
        Canvas canvas = new Canvas(output);

        final int color = 0xff424242;
        final Paint paint = new Paint();
        final Rect rect = new Rect(0, 0, width, height);
        final RectF rectF = new RectF(rect);
        final float roundPx = 90; 

        paint.setAntiAlias(true);
        canvas.drawARGB(0, 0, 0, 0);
        paint.setColor(color);
        canvas.drawRoundRect(rectF, roundPx, roundPx, paint);

        paint.setXfermode(new PorterDuffXfermode(Mode.SRC_IN));
        canvas.drawBitmap(bitmap, rect, rect, paint);

        return output;
}

Para hacer el efecto que os he descrito solo necesitáis este método, este recibirá como parámetros un objeto Drawable que es la imagen que vamos a tratar y ademas un boolean que lo que va a hacer es hacer cuadrada la imagen o no. Esto es muy útil cuando no sabemos los tamaños de las imágenes que vamos a tratar y decimos que todas irán cuadradas para no perjudicar el diseño de la aplicación.

El método comienza convirtiendo a Bitmap nuestra imagen, despues de eso, si la imagen va a ser cuadrada cogemos el menor de los tamaños para el ancho y alto.

Luego creamos un nuevo Bitmap con las dimensiones antes calculadas, y un lienzo (canvas) donde haremos el efecto redondeado. canvas lo instanciamos con el Bitmap output sobre el que realizará los cambios y finalmente devolverá este bitmap modificado.

Aquí lo realmente importante es la variable roundPx la cual nos dará el ángulo de curvatura de nuestros bordes, cuanto más grande sea, más redondeada será la foto. Podéis hacer que sea totalmente redonda si ponéis el valor a 360 y hacéis que sea cuadrada la foto.

Una vez se aplican todos los efectos, el objeto canvas pinta el bitmap con todas las configuraciones tomando como base bitmap y devolviendo output.

Veamos ahora como utilizar este método, en primer lugar, el método lo podeis poner en vuestra activity principal para hacer pruebas por simplicidad, pero lo mejor siempre es que os lleveis este método a una clase para poder utilizarlo con más comodidad en toda vuestra aplicación.

ImageView imageView = new ImageView(this);
imageView.setImageBitmap(getRoundedCornerBitmap(getResources().getDrawable(R.id.image), true));

En nuestro layout definimos un objeto ImageView que llamaremos imageView y en nuestro activity antes de nada inicializamos este objeto, después seteamos directamente la imagen llamando a nuestro método de redondear imagenes. El objeto drawable lo obtenemos gracias a getResources y getDrawable, al cual le indicamos una imagen cualquiera de nuestra aplicación (las que están en la carpeta drawable).

Esta vez la imagen utilizada está guardada previamente en nuestra aplicación y lo cierto es que podríamos editarla nosotros y nos ahorraríamos este esfuerzo innecesario, lo realmente interesante sería disponer de un repositorio de imagenes en un servidor y nutrirnos de él para enriquecer nuestra aplicación. En próximas entregas veremos como descargar una imagen para que las podáis utilizar en vuestras aplicaciones. Por el momento espero que os haya sido útil este truco.

Seleccionando imagenes en Android (estilo Facebook)

2011-12-28T13:23:00.001+01:00

Buenas, esta semana vamos a ver como seleccionar imagenes para nuestra aplicación. El proceso es el mismo que podemos ver en aplicaciones tan conocidas como Facebook, Twitter, etc... presentes en nuestros teléfonos móviles, y porque no, también en vuestras aplicaciones a partir de ahora si queréis.

Empiezo explicandoos un poco el proceso, este es muy simple, y tiene que ver un poco con lo que vimos la semana pasada, reconocer voz en Android. Tenemos un botón el cual abre una ventana de dialogo y nos pregunta si queremos hacer una foto o elegirla de la galeria. En función de lo que elegimos, lanzaremos un Intent (acción) del sistema de Android u otra. Una llamará al programa que gestiona la galería y otro al que gestiona la cámara.

Una vez hecha la foto o seleccionada, se devolverá un resultado, el cual capturamos en onActivityResult y nos devolverá en uno de sus parámetros la dirección URI de la foto, la cual trataremos como mejor nos convenga. Vamos entonces a ver como hacerlo.

Abrimos el activity principal de nuestro proyecto, insertais los siguientes objetos en el layout y los inicializais antes de nada, un Button, ImageView y TextView a los cuales yo llamaré btnPhoto, imgPhoto y lblPhoto. No os pongo el código para esto ya que hemos visto como hacer esto en artículos anteriores. Seteamos el click de nuestro botón para que lance la ventana de diálogo para seleccionar entre hacer una foto o seleccionarla.

btnPhoto.setOnClickListener(new OnClickListener() {   
 public void onClick(View v) {
  dialogPhoto();
 }
});

Y aquí está el código que abre la ventana de diálogo:


private int SELECT_IMAGE = 237487;
private int TAKE_PICTURE = 829038;

private void dialogPhoto(){
     try{
  final CharSequence[] items = {"Seleccionar de la galería", "Hacer una foto"};

  AlertDialog.Builder builder = new AlertDialog.Builder(this);
  builder.setTitle("Seleccionar una foto");
  builder.setItems(items, new DialogInterface.OnClickListener() {
    public void onClick(DialogInterface dialog, int item) {
      switch(item){
       case 0:
     Intent intent = new Intent(Intent.ACTION_PICK, android.provider.MediaStore.Images.Media.INTERNAL_CONTENT_URI);
     intent.setType("image/*");
     startActivityForResult(intent, SELECT_IMAGE);   
     break;
       case 1:
     startActivityForResult(new Intent(android.provider.MediaStore.ACTION_IMAGE_CAPTURE), TAKE_PICTURE);
     break;
      }
            
    }
  });
  AlertDialog alert = builder.create();
  alert.show(); 
     } catch(Exception e){}
    }

Lo primero que se hace es definir dos variables para poder identificar en el onActivityResult que intent se lanzó. Ya en el método, definimos en un array las dos opciones de la ventana. Contruimos la ventana de diálogo dandolo un título y añadiendo las opciones que mostraremos. También definimos el click para cada uno de los items, y con el switch decidimos que sucederá en cada caso.

En los dos casos llamamos a un Intent del sistema, y mediante el método startActivityForResult hacemos la llamada pasandole como segundo parámetro cada una de las variables que definimos al principio.

En el caso de la selección de foto, le indicamos el tipo para que solo seleccione imagenes, en caso contrario podría seleccionar cualquier archivo.

Vamos a ver que es lo que debemos hacer una vez que el usuario haya seleccionado una foto. Ahora debemos sobreescribir el método onActivityResult de nuestra activity. Os muestro como:

@Override
    public void onActivityResult(int requestCode, int resultCode, Intent data) {
      super.onActivityResult(requestCode, resultCode, data);
          
      try{
 if (requestCode == SELECT_IMAGE)
    if (resultCode == Activity.RESULT_OK) {
      Uri selectedImage = data.getData();
      lblPhoto.setText(getPath(selectedImage));
             imgPhoto.setImageURI(selectedImage); 
            } 
        if(requestCode == TAKE_PICTURE)
    if(resultCode == Activity.RESULT_OK){
      Uri selectedImage = data.getData();
      lblPhoto.setText(getPath(selectedImage));  
             imgPhoto.setImageURI(selectedImage); 
            }
      } catch(Exception e){}
    }

Como podeis ver el método es muy sencillo, verificamos que acción estamos recogiendo y si todo fue bien, en ese caso, obtenemos la imagen en una dirección URI. En el caso de la etiqueta parseamos la dirección con el método getPath que os mostraré ahora, y en el caso de la imagen, seteamos la imagen con el método setImageUri.

Os pongo ahora que haría el método getPath:

private String getPath(Uri uri) {
 String[] projection = { android.provider.MediaStore.Images.Media.DATA };
 Cursor cursor = managedQuery(uri, projection, null, null, null);
 int column_index = cursor.getColumnIndexOrThrow(android.provider.MediaStore.Images.Media.DATA);
 cursor.moveToFirst();
 return cursor.getString(column_index);
   }

Como veis, estamos parseando la dirección URI a una String, la cual devolvemos al final.

Y así acabamos de seleccionar imagenes. Como veis no es muy complicado implementarlo en vuestras aplicaciones y seguro que dará mucho juego en vuestros desarrollos. Hasta la semana que viene.

P.D: Feliz día de los santos inocentes.

Script para crear lanzadores personalizados

2011-12-22T00:05:00.000+01:00

Hace un tiempo publicamos una entrada en la que se explicaba cómo crear, de forma manual, lanzadores personalizados para Unity. En este caso, vamos a ver un sencillo script que nos permite automatizar dicha tarea; únicamente tendremos que facilitarle los siguientes datos:

- Nombre del lanzador (ej: Eclipse).
- Ruta completa del archivo ejecutable (ej: /home/miusuario/eclipse/eclipse).
- Ruta completa del archivo de icono (ej: /home/miusuario/eclipse/icon.xpm).

El código del script es el siguiente:

#!/bin/bash

read -p "Nombre del lanzador: " NOMBRE                      # Se nos pide el nombre del lanzador.
if [ -e /usr/share/applications/$NOMBRE.desktop ]; then     # Si el lanzador ya existe...
 echo "ERROR: El lanzador ya existe.  Abortado."
 exit                                                # ...salimos del script.
fi

read -p "Ruta completa del archivo ejecutable: " RUTAEXE    # Se nos pide la ruta completa del archivo ejecutable.
if [ ! -e $RUTAEXE ]; then                                  # Si el archivo ejecutable no existe...
 echo "ERROR: El archivo no existe.  Abortado."
 exit                                                # ...salimos del script.
elif [ ! -x $RUTAEXE ]; then                                # O si el archivo no es ejecutable...
 echo "ERROR: El archivo no es ejecutable.  Abortado."
 exit                                                # ...salimos del script.
fi

read -p "Ruta completa del archivo de icono: " RUTAICO      # Se nos pide la ruta completa del archivo de icono.
if [ ! -e $RUTAICO ]; then                                  # Si el archivo de icono no existe...
 echo "ERROR: El archivo no existe.  Abortado."
 exit                                                # ...salimos del script.
fi

echo "[Desktop Entry]" > $NOMBRE.desktop                    # Creamos el archivo lanzador
echo "Type=Application" >> $NOMBRE.desktop                  # escribiendo en él los datos
echo "Terminal=false" >> $NOMBRE.desktop                    # anteriormente facilitados.
echo "Name=$NOMBRE" >> $NOMBRE.desktop
echo "Exec=$RUTAEXE" >> $NOMBRE.desktop
echo "Icon=$RUTAICO" >> $NOMBRE.desktop

echo "Lanzador creado."
echo "Ahora se moverá al directorio '/usr/share/applications/'."
echo "Introduce tu contraseña de 'root' si es necesario."

sudo chown root:root $NOMBRE.desktop                        # Hacemos que el lanzador pertenezca a root
sudo mv $NOMBRE.desktop /usr/share/applications/            # y lo enviamos al directorio de los lanzadores.

read -n 1 -p "Finalizado.  Pulsa una tecla para salir..."
echo ""

Para poder hace uso de este script, debemos guardar su código en un archivo y darle permiso de ejecución. Yo le he llamado lanzpers.sh y le he otorgado dicho permiso desde la terminal con chmod +x lanzpers.sh . En la siguiente captura tenemos un ejemplo de ejecución:

Comprobamos que el contenido del lanzador recién creado es el correcto:

Lo más cómodo es poder utilizar el script sin abrir una terminal. Para ello, sólo tenemos que activar la ejecución de archivos de texto en Nautilus - Editar - Preferencias; cualquiera de las dos opciones marcadas en verde es válida:

Saludos.

Cómo reconocer voz con Android

2011-12-20T23:13:00.003+01:00

Buenas, esta semana vamos a ver como reconocer comandos de voz en nuestra aplicación. Android trae implementado el reconocimiento de voz en su API por lo que no es necesario hacer una gran aplicación para poder disponer de esta funcionalidad.

Para empezar lo que necesitamos es decirle a nuestra aplicación cuales son los permisos que necesitará. Si os acordais, la semana pasada vimos como dar permisos en el archivo AndroidManifest.xml. Esta semana daremos permisos para poder acceder a internet. Para ello debemos añadir la siguiente línea dentro del archivo antes mencionado:

<uses-permission android:name="android.permission.INTERNET" />

Una vez hecho este paso previo vamos a implementar el reconocimiento de voz. Para ello abrimos nuestra activity principal e incluimos el siguiente código:

private static final int VOICE_RECOGNITION_REQUEST_CODE = 1234;
Private Button btnVoice;

private void inicializarReconocimiento(){
btnVoice = (Button) findViewById(R.id.btnVoice);
PackageManager pm = getPackageManager();
       
List<ResolveInfo> activities = pm.queryIntentActivities(new                    Intent(RecognizerIntent.ACTION_RECOGNIZE_SPEECH), 0);
       
  if (activities.size() != 0) {
          
    btnVoice.setOnClickListener(new OnClickListener() {
    
    
       public void onClick(View v) {
     
          startVoiceRecognitionActivity();
    
       }
   
    });
       
  } 
}

Lo que estamos haciendo aquí es inicializar un botón para poder lanzar el reconocimiento y comprobando que está disponible este servicio en el dispositivo. Vamos a ver que es lo que hace el método startVoiceRecognitionActivity que lanza nuestro botón.

private void startVoiceRecognitionActivity() {        Intent intent = new Intent(RecognizerIntent.ACTION_RECOGNIZE_SPEECH);
        intent.putExtra(RecognizerIntent.EXTRA_LANGUAGE_MODEL,
                RecognizerIntent.LANGUAGE_MODEL_FREE_FORM);
        intent.putExtra(RecognizerIntent.EXTRA_PROMPT, "");
        startActivityForResult(intent, VOICE_RECOGNITION_REQUEST_CODE);
    }

Como veis, el método es muy sencillo . Lo que hace es llamar al intent correspondiente del reconocimiento, abriendo una nueva actividad que devolverá un resultado, en este caso devolverá los posibles resultados. Tambien le pasamos la variable VOICE_RECOGNITION_REQUEST_CODE que luego utilizaremos en el método onActivityResult. Esto veremos ahora para que sirve.

@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
        
 if (requestCode == VOICE_RECOGNITION_REQUEST_CODE && resultCode == RESULT_OK) {
          
  ArrayList<String> matches = data.getStringArrayListExtra(RecognizerIntent.EXTRA_RESULTS);
             
         
  final CharSequence[] items = new CharSequence[matches.size()];
   
  for(int i = 0; i < matches.size(); i++){
    
    items[i] = matches.get(i);
   
  }
         
         
  AlertDialog.Builder builder = new AlertDialog.Builder(this);
  builder.setTitle(selectResult);        
  builder.setItems(items, new DialogInterface.OnClickListener() {
    public void onClick(DialogInterface dialog, int item) {
     txtSearch.setText(items[item].toString());              
     }
  });
         
  AlertDialog alert = builder.create();
         
  alert.show();
            
        
 }

        
 super.onActivityResult(requestCode, resultCode, data);
    
}

Lo que estamos haciendo ahora es sobreescribir el método OnActivityResult de nuestro activity. Este método es lanzado cuando una activity secundaria que hemos lanzado desde nuestra activity principal devuelve un resultado . Por ejemplo, después de reconocer lo que hemos dicho, devolverá un resultado con las posibles frases que ha reconocido el servicio.

Lo primero que hacemos es verificar el resultCode que es una especie de identificador para saber de que activity proviene el resultado. Es para esto para lo que utilizamos la variable anterior.

También verificamos que el resultado de nuestra activity secundaria ha sido satisfactorio con resultCode.

Una vez hechas las comprobaciones parseamos los resultados que en este caso va a ser una lista de frases y los cuales podemos mostrar con un AlertDialog por ejemplo. En este seleccionamos un resultado y lo seteamos en un TextView, txtSearch. A partir de aquí el como se utilicen los resultados ya es cosa de cada uno.

Guía para crear un Servidor DNS en Ubuntu Parte 2

2011-12-20T14:00:00.048+01:00

Continuamos con la guía para tener nuestro propio servidor DNS en nuestro ordenador ubuntu. Para proseguir, debes tener realizada la primera parte de este tutorial, y ya damos por supuesto que tenemos conocimientos mínimos de DNS, sino aquí puedes obtener unas referencias muy simples sobre estos amigos nuestros.

La semana pasada habíamos instalado el software de servidor DNS "BIND9" y el módulo para webmin y así poder administrarlo más fácilmente.

¿Qué vamos a hacer?

Zona Primaria

Creación de zona de búsqueda directa.
Creación de zona de búsqueda inversa.
Creación de registros para ambas zonas.

Segunda parte

Al iniciar webmin entraremos en la pestaña de servidores, y ahí le daremos a Servidor de DNS BIND, y obtendremos algo como esto:

Crear una zona primaria (o maestra) de búsqueda directa

Lo primero que debemos hacer es crear una Zona Primaria, que es la más importante, es capaz de leer y escribir en el servidor los nombres y las direcciones.

Así que nos dirigimos a la zona inferior de la página y nos fijamos en la parte denominada: Zonas DNS Existentes. Aquí vemos que hay varias zonas creadas por defecto:

Zona Raíz: Sirve para poder resolver nombres que no estén en el propio servidor DNS, normalmente este servidor raíz es el de Internet.
0,127,255 y localhost: Son Zonas maestras para controlar el trabajo en la máquina o "localhost", por lo cual no es recomendable tocarlos.

Pero nosotros vamos a crear una para nuestros propósitos, personalizable y posteriormente modificable sin excesivo riesgo.

Así que seleccionamos "Crear una nueva zona maestra" (Sí, yo también me he fijado que en webmin tiene un error tipográfico). Y nos aparecerá una nueva página de configuración de nuestra Zona Maestra.

Una vez aquí, tenemos que poner obligatoriamente cuatro de todos los campos propuestos:

Debemos elegir el tipo de zona, que en este caso como es Zona Primaria de búsqueda directa, es decir, traducirá nombres en direcciones IP.

Le daremos un nombre a la zona maestra, en mi caso: "nosinmiubuntu" es recomendable no usar espacios en blanco.

Nombraremos también al ordenador servidor para poder identificarlo.

Introducimos un e-mail para que envíe las notificaciones (podemos inventarlo).

Cuando le damos a crear, nos aparece el menú de nuestra zona ya creada. En la cual podemos editarla y modificarla.

El archivo de configuración es:

/etc/bind/named.conf.local

Crear un registro en la zona primaria (búsqueda directa)

Queremos crear un registro que dirija un nombre a una dirección. Nos debemos dirigir a la sección (de nuestra Zona Primaria) Dirección.

Y una vez dentro nos aparece una tabla para agregar un nuevo registro. En la caja de nombre, debemos insertar el nombre por el que queremos reconocer a ese ordenador en la red. Y en dirección, la dirección IP del mismo ordenador. Marcamos la opción NO en actualizar inversas, porque aún no tenemos la zona de búsqueda inversa.Le damos al crear, y ya está añadido el registro. Sería algo parecido a esto:

Y como podemos ver nos aparecerá una nueva tabla con las direcciones que tenemos dadas de alta en nuestro servidor:

Y el archivo de configuración es dependiendo del nombre de nuestra zona. simplemente debéis cambiar "nosinmiubuntu" y poner el nombre de vuestra zona:

/var/lib/bind/[nosinmiubuntu].hosts

Crear una zona primaria (o maestra) de búsqueda inversa

Ahora vamos a crear una zona maestra, pero en este caso de búsqueda inversa, que es el contrario de la anteriormente creada, ésta recibe IPs y las traduce en nombres.

Debemos dirigirnos a la página de nuestro servidor DNS y volvemos a crear una Zona Maestra, pero en este caso, debemos cambiar algunos parámetros:

Indicaremos que queremos que sea de tipo inversa.
En "Nombre de dominio/Red" debemos escribir la red en la cual se encuentre, pero sólo los números de la IP que identifiquen a la red, sin los números hosts.
Introducir el e-mail, que puede ser el mismo, o inventado

Y nos creará la zona de búsqueda inversa. Que podremos modificar también en el mismo archivo de configuración que la zona de búsqueda directa.

Crear un registro en la zona maestra (búsqueda inversa)

Nos dirigiremos a la Zona Maestra de búsqueda inversa, y hacemos clic en el icono que pone "Dirección Inversa".

Ahí debemos introducir la dirección y la IP del ordenador y en el recuadro de abajo, escribiremos la dirección que tiene en el dominio. Que sigue la estructura:

máquina.nombre_dominio.

Nota:

Es importante que todas las direcciones de este timpo tengan el punto final, ya que éste significa que primero debe dirigirse a la raíz del servidor, luego a la zona de búsqueda y, finalmente a ese ordenador en concreto. Tiene el funcionamiento de las páginas web

Y hoy llegamos hasta aquí. La próxima semana, con la tercera entrega, terminaremos de arreglar los últimos flecos de nuestro servidor. Muchas gracias por vuestro seguimiento.

[Solución] vesamenu.c32: Not a COM32R image

2011-12-19T20:04:00.002+01:00

Ya hemos hablado en el blog sobre Cómo crear un Live-usb de cualquier distribución, una muy buena opción para instalar nuestro sistema operativo, ya que además de ahorrarnos tener que grabar un CD/DVD, nos acelera el proceso de copia por ser desde una memoria USB a un disco duro, y no tener que hacer uso del dispositivo óptico.

En las últimas semanas he creado varios Live-USB de Ubuntu con el Creador de discos de arranque (usb-creator-gtk) , dándome el siguiente error al arrancar:

vesamenu.c32: Not a COM32R image
boot:

Según podemos leer en el blog de Jorge Iván Meza Martínez, el problema está causado por la versión de syslinux que viene instalada por defecto en las series Ubuntu 10.x y 11.x, aunque personalmente empezó a darme problemas recientemente, incluso en la 11.10 hice alguno y no me dio el error.

Para solucionarlo existen dos soluciones. La primera de ellas podemos decir que es temporal ya que tendremos que usarla cada vez que querramos arrancar con el USB de instalación. Para ello, una vez arranquemos, nos aparecerá el dichoso error, que haremos desaparecer pulsando el Tabulador y escribiendo

live

La segunda solución, ya definitiva, es crear estos Live-USB con Unetbootin, del que ya explicamos cómo usarlo en otra entrada, y con el que dejaremos de sufrir el problema mencionado en la entrada.

Como ya he comentado al inicio, y aun a riesgo de repetirme, personalmente desde que existe la posibilidad de crear los discos de instalación para cualquier distribución en un USB, he dejado de "malgastar CDs", aumentando la rapidez del proceso, algo que me hace recomendar esta opción.

Saludos.

El Escritorio del Lector #56

2011-12-18T16:53:00.001+01:00

Un domingo más, como no podría ser de otra manera, volvemos con "El Escritorio del Lector". Con más de un año de duración, esta sección existe gracias a vosotr@s, conviertiéndose en un clásico dentro del blog, algo que me hace especial ilusión. Como bien sabéis, el protagonista puede ser tú, tan sólo tienes que querer mostrar cómo es el área de trabajo donde se maneja, para que el resto conozcamos nuevos paquetes de iconos, temas, etc. Una muy buena forma de compartir vuestro trabajo a la hora de dejar lo más cómodo posible el Escritorio.

En el penúltimo domingo del año nos visita @georgevazj, quien gracias a una de nuestras invitaciones a través de Twitter quiso participar en la sección. Jorge nos trae un área de trabajo con openSUSE como sistema operativo, y KDE como entorno, el cual siempre ha destacado por su vistosidad.

S.O.: openSUSE 11.10

Entorno de escritorio: KDE 4

Iconos: Kfaenza

Tema: Aire-oxigeno (por defecto)

Otros: Yakuake para que el acceso a la terminal sea más cómodo y bonito.

Cómo guardar datos en Android: Archivos

2011-12-14T16:59:00.000+01:00

Buenas, estas semanas hemos aprendido a guardar datos de configuración mediante las SharedPreferences y en base de datos SQLite. Esta semana veremos otra forma de guardar datos, esta vez serán archivos. Crearemos un archivo y lo guardaremos en la tarjeta SD de nuestro dispositivo.

Lo primero que vamos a hacer es crear una clase que nos ayude a gestionar los archivos, la llamaremos filemanager ya que estaŕa destinada a gestionar archivos.

Las tarjetas SD pueden estar o no presentes en nuestro dispositivo por lo que antes de empezar a escribir o leer en ella nos aseguraremos que existe y podemos escribir en ella, para ello crearemos dos métodos estáticos (no tiene que existir una instancia de la clase para ser utilizadas), sus nombres son bastante significativos. El código es el siguiente y lo ubicamos dentro de nuestra clase nueva:

public static boolean isExternalStorageReadOnly() {  
 String extStorageState = Environment.getExternalStorageState();  
     if (Environment.MEDIA_MOUNTED_READ_ONLY.equals(extStorageState)) {  
         return true;  
     }  
     return false;  
}  
   
public static boolean isExternalStorageAvailable() {  
     String extStorageState = Environment.getExternalStorageState();  
     if (Environment.MEDIA_MOUNTED.equals(extStorageState)) {  
         return true;  
     }  
     return false;  
}

Lo siguiente que haremos será crear y escribir nuestro primer archivo, para ello vamos a utilizar el método getExternalStorageDirectory, el cual utilizaremos para poder obtener la ruta de nuestra tarjeta SD. Crearemos un nuevo objeto de tipo File con el cual podremos manejar todos nuestros archivos. En este caso le estamos pasando un nombre de archivo y el texto que insertaremos en el archivo mediante un OutPutStreamWriter. Una vez escrito cerramos todo y listo.

public void writeFile(String filename, String textfile){
try {
  if (isExternalStorageAvailable() && !isExternalStorageReadOnly()) { 
   File file = new File(Environment.getExternalStorageDirectory(), filename );
   OutputStreamWriter outw = new OutputStreamWriter(new FileOutputStream(file));
   outw.write(textfile);
   outw.close();
}
} catch (Exception e) {}  
}

En principio este sería todo el código necesario para poder escribir un archivo, pero para poder escribir, Android nos tiene que dejar escribir. ¿Cómo hacemos esto? Esto lo haremos diciéndole a Android que nuestra aplicación necesita permisos de escritura. Estos permisos se declaran en el archivo AndroidManifest.xml y es una especie de archivo global donde tenemos los permisos, el nombre de la aplicación, icono, y un montón de cosas que iremos mencionando aquí a medida que las vayamos necesitando. En este caso, hoy veremos como declarar permisos, en concreto este:

android.permission.WRITE_EXTERNAL_STORAGE
Abrimos nuestro archivo AndroidManifest.xml e insertamos la siguiente línea dentro del nodo manifest:

<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />

Este permiso será el que luego aparezca detallado cuando veáis las propiedades de la aplicación instalada en vuestro teléfono o al descargarla del Market cuando os indiquen que permisos requiere.

Una vez hecho esto vamos a por el último paso, leer el archivo que hemos escrito antes.

public String readFile(String filename){
 try{
  if(isExternalStorageAvailable()){
   File file = new File(Environment.getExternalStorageDirectory(), filename);
   BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream(file)));
   String t = br.readLine();
   br.close();
   return t;
  } else {return "";}   
 } catch(Exception e){return "";}
}

En el método de lectura solamente compruebo que la tarjeta SD este disponible ya que solo voy a leer, vuelvo a crear un objeto tipo File para abrir el archivo que creamos antes y con un BufferedReader leemos el contenido y lo volcamos en una variable de tipo String, cerramos todo y devolvemos el texto leído.

Con estos cuatro métodos ya podeis empezar a manejar archivos, guardarlos y escribirlos en vuestra tarjeta SD, ahora os añado un pequeño ejemplo practico que podéis utilizar por ejemplo en nuestra activity, volcando el texto leído un TextView por ejemplo.

TextView lbl = (TextView) findViewById(R.id.lbl);
filemanager fm = new filemanager();
fm.writeFile("holamundo.txt", "nosinmiubuntu");
lbl.setText(fm.readFile("holamundo.txt"));

Por último, si estais probando este ejemplo en el emulador de Android aseguraros que vuestro dispositivo virtual tiene declarada una tarjeta SD, no es necesario que el espacio asignado sea muy grande para este ejemplo.

Guía para crear un Servidor DNS en Ubuntu Parte 1

2011-12-13T15:45:00.000+01:00

Introducción

Hoy por fin veremos cómo se crea un servidor DNS en un ordenador que tenga un sistema operativo que puede ser Ubuntu 11.10. Vamos a necesitar una serie de pasos previos de los que ya hemos hablado en anteriores artículos como son:

Breve introducción de servidores DNS.
Tener instalado el administrador de sistema webmin.
Saber configurar webmin e instalar módulos.

Bien, una vez sepamos qué son los DNS, para qué pueden ser útiles, además de tener instalado webmin, procedemos a comenzar la guía.

Instalación de BIND 9

Lo primero que debemos hacer es poner una dirección IP estática o manual, porque el servidor DNS debe estar siempre localizable en una dirección. Eso lo conseguimos entrando en Conexiones de Red. Y ponemos configuramos las IP dependiendo de nuestro Router.

Ahora debemos instalar el programa que permite que nuestro ordenador ser un servidor DNS. Este programa se llama BIND9.

Para instalar el programa, podemos usar el centro de software ubuntu buscando "bind 9".

O simplemente usamos la consola de comandos escribiendo:

sudo apt-get install bind9

Si tras esto necesitamos instalar las dependencias, escribimos en la consola:

sudo apt-get install -f

Desde la consola, como podemos ver, tras instalar el programa, nos muestra que ha arrancado el servicio de nombres de servicio llamado bind9:

Ahora lo que debemos hacer es instalar el módulo, o extensión del webmin para bind. La podemos instalar desde el repositorio oficial de webmin. En el un artículo anterior vimos cómo instalar módulos.

Instalamos el BIND8, que servirá para modificar el BIND9.

Una vez instalado el módulo debemos darle a "Refresh Modules" para que actualice la lista de módulos de webmin.

Una vez instalado esto, ya tenemos todo preparado para funcionar.

Ya sólo queda la configuración para poder dar de alta máquinas y relacionarlas con los nombres. La semana que viene trataremos este asunto en profundidad.

[Solución] Cover Thumbnailer en Ubuntu 11.10/Gnome 3

2011-12-12T19:26:00.003+01:00

Hace aproximadamente un año hablábamos sobre Cover Thumbnailer, un script escrito en Python que nos cambia la miniatura de las carpetas con Música o Imágenes, por la previsualización de las carátulas o imágenes que haya en su interior.

Por alguna razón, después del paso a Gnome 3 este script tan elegante no funciona correctamente, haciéndolo únicamente (por lo menos en mi caso) con las canciones que tienen la carátula. Para que esta aplicación vuelva a funcionar como debe, simplemente hay que realizar una serie de ajustes, los cuales he sabido hacer gracias a Tachiblog.

En primer lugar debemos crear el archivo con el nombre cover-thumbnailer.thumbnailer en la carpeta /usr/share/thumbnailers/ con la siguiente orden:

sudo gedit /usr/share/thumbnailers/cover-thumbnailer.thumbnailer

El archivo creado deberá contener lo siguiente:

[Thumbnailer Entry]
TryExec=cover-thumbnailer
Exec=cover-thumbnailer %u %o
MimeType=inode/directory;

Ahora sólo queda guardar los cambios realizados una vez introducidas las líneas anteriores y aplicar lo siguiente en terminal:

export GCONF_CONFIG_SOURCE=`gconftool-2 –get-default-source`

gconftool-2 –makefile-install-rule /etc/gconf/schemas/cover-thumbnailer.schemas

Si has seguido todos los pasos Cover Thumbnailer volverá a funcionar, y una vez abras un directorio por ejemplo con Música se verá algo similar a la imagen.

En realidad aunque aparentemente no es un complemento de mucha utilidad, da un aspecto elegante las carpetas con Música o Imágenes, y nos facilita la identificación de algunas de ellas.

Saludos.

El Escritorio del Lector #55

2011-12-11T12:00:00.049+01:00

Después de un largo puente y domingo más, como no podría ser de otra manera, volvemos con "El Escritorio del Lector". Con un año de duración, esta sección existe gracias a vosotr@s, conviertiéndose en un clásico dentro del blog, algo que me hace especial ilusión. Como bien sabéis, el protagonista puede ser tú, tan sólo tienes que querer mostrar cómo es el área de trabajo donde se maneja, para que el resto conozcamos nuevos paquetes de iconos, temas, etc. Una muy buena forma de compartir vuestro trabajo a la hora de dejar lo más cómodo posible el Escritorio.

El Escritorio número 55 viene de la mano de Fernando Rubio, quien lo ha personalizado a su gusto, cambiando todo tipo de detalles como tipografía, iconos, fondo, tema de ventanas, y añadiendo conky, además de un par de complementos al panel como son Jupiter y My weather indicator.

S.O.: Ubuntu 11.10

Fondo de escritorio: Relax de Elementary
Tema de Ventada: Zukwito Resonance
Tema de Iconos: Faience
Tipografía: Janda Swirlgirl
Conky: Reloj
Extras: My-Weather-Indicator y Jupiter (Power Management)

Visualiza el Thumbnail/miniatura de tus documentos con lo-thumbnailer

2011-12-09T18:00:00.006+01:00

Mientras nos encontramos navegando por Nautilus, podemos ver una miniatura de los archivos PDF, de vídeo o imágenes, pero no de documentos en LibreOffice. Aunque hace algo más de un año hablamos de un complemento que nos daba la posibilidad de hacerlo tanto para OpenOffice como para LibreOffice, éste ya no sirve para el paquete ofimático desarrollado por The Document Foundation en Ubuntu 11.10.

Si queremos volver a disponer de estas miniaturas, bastará con instalar un complemento desarrollado por Giorgio Maccari, y que es válido para cualquier archivo creado en LibreOffice, incluso los creados en Microsoft Office. Para ello deberemos añadir su repositorio, actualizar la lista de paquetes e instalar lo-thumbnailer, todo ello mediante siguientes órdenes:

sudo add-apt-repository ppa:giorgio-maccari/ppa-marrano

sudo apt-get update

sudo apt-get install lo-thumbnailer

Finalmente bastará con reiniciar Nautilus con:

nautilus -q

Como podréis observar en la imagen, nos indica el tipo de archivo que es con su correspondiente icono en la parte inferior derecha.

Nota:

Desgraciadamente el repositorio sólo está disponible para Ubuntu 11.10

Con esta entrada seguimos hablando de LibreOffice, un tema que ya se ha convertido en un clásico dentro del blog por sus continuos lanzamientos de versiones y novedades, algo que demuestra la gran Comunidad que tiene detrás.

Saludos.

Añadir atajos de teclado en GNOME Shell

2011-12-08T11:13:00.000+01:00

Los que hayáis utilizado Unity y ahora decidáis usar GNOME Shell, os encontraréis con que existen muchos menos atajos de teclado para la ejecución de aplicaciones. En realidad, esto no supone un problema, y sólo tendréis que invertir un poco de vuestro tiempo para crear los atajos más utilizados.
Vamos a mostraros un sencillo ejemplo de cómo crear un nuevo atajo de teclado; en este caso, la combinación de teclas elegida abrirá la aplicación Brasero:

1. En primer lugar, buscamos y ejecutamos el configurador de Teclado:

2. A continuación, dentro de la pestaña Atajos, seleccionamos la opción Combinación personalizada y pulsamos el botón + :

3. En este punto, necesitamos saber cuál es la ruta completa del ejecutable de Brasero en el árbol de directorios; para obtener esta información, abrimos una terminal y utilizamos el comando which:

4. Le damos un nombre al atajo, introducimos la ruta del ejecutable proporcionada por which (/usr/bin/brasero) y pulsamos el botón Aplicar:

5. Por defecto, el atajo aparece como Desactivado, pero si hacemos click sobre él cambiará a Combinación nueva... :

6. Es entonces cuando podremos pulsar la combinación de teclas que tengamos en mente para ejecutar Brasero; en este caso, he elegido Ctrl + Alt + B. Sólo resta cerrar la ventana de configuración del teclado, y ya podremos abrir Brasero pulsando dicha combinación:

Como siempre, esperamos que os sirva de ayuda.
Un cordial saludo.