miércoles, 28 de diciembre de 2011

Seleccionando imagenes en Android (estilo Facebook)

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.

jueves, 22 de diciembre de 2011

Script para crear lanzadores personalizados

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.

martes, 20 de diciembre de 2011

Cómo reconocer voz con Android


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

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.

    lunes, 19 de diciembre de 2011

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

    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.

    domingo, 18 de diciembre de 2011

    El Escritorio del Lector #56

    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.






    • Entorno de escritorio: KDE 4
    • Tema: Aire-oxigeno (por defecto)
    • Otros: Yakuake para que el acceso a la terminal sea más cómodo y bonito. 
     
    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. 

    miércoles, 14 de diciembre de 2011

    Cómo guardar datos en Android: Archivos


    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.

    martes, 13 de diciembre de 2011

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

    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: 


    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.

    lunes, 12 de diciembre de 2011

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

    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.

    domingo, 11 de diciembre de 2011

    El Escritorio del Lector #55

    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.

     

    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. 
    Licencia de Creative Commons