¿Cómo desarrollar para Android? - Parte II

En la entrega anterior expliqué como instalar el ambiente de desarrollo para trabajar con Android. Ahora explicaré algunos fundamentos necesarios para poder entrar en calor.

Podemos decir que Android está compuesto por varias capas (muy al estilo del modelo OSI).

Esas capas las podemos diferenciar en 5 grupos:

• Capa 1 - Kernel: La base de Android es sólida como una roca. Claro, esa base es el kernel Linux. Android usa Linux para manejar todo lo relacionado con el hardware (drivers), gestionar la memoria, los procesos y muchas otras tareas operativas. Sin embargo nuestra aplicación nunca tocará el kernel.
• Capa 2 - Librerías nativas: La siguiente capa que se ubica por encima del kernel son las librerías nativas. Allí tenemos una serie de herramientas que vienen precompiladas por el fabricante y que nos permiten manejar desde renderizado web hasta bases de datos.
• Capa 3 - Núcleo: Sobre ésta capa tenemos el núcleo de Android. Allí reside la máquina virtual Dalvik y las librerías de la plataforma.
• Capa 4 - Framework para aplicaciones: Más arriba está el conjunto de herramientas que nos permite crear y manejar las aplicaciones, notificaciones, recursos y muchas otras cosas.
• Capa 5 - Aplicaciones: Y por último tenemos la capa de aplicaciones, aquí es donde se encuentran los widgets y todas las aplicaciones que tienen contacto con el usuario.

Ya conocemos un poco mejor la arquitectura de Android, ahora veamos con qué contamos para desarrollar. Parte del framework para aplicaciones son los componentes. Estuadiaremos los más importantes por el momento, ellos son:

• Activities: Los activities (o actividades) son las interfaces que permiten al usuario interactuar con la aplicación. Generalmente una aplicación está compuesta de muchas actividades. Una actividad puede ser mostrar la lista de contactos y otra puede ser enviar mensajes de texto
• Intents: Un intent (o como se diría en español, una "intención") no es más que una acción. En Android todas las acciones se manejan con intenciones ;)
• Services: Es una tarea que se ejecuta en segundo plano, sin interfaz gráfica y sin interacción directa con el usuario. Podemos pensar en el ejemplo típico: un reproductor de música. A todos nos gusta que la música siga sonando incluso si dejamos de ver el reprouctor para pasarnos al navegador web. Eso es un servicio
• Content Providers: Es un contenedor que permite agrupar un conjunto de datos de una aplicación y ponerlos a disposición de otras aplicaciones. Podemos verlo como una manera de compartir información global entre aplicaciones

Por último vamos a mencionar las fases del ciclo de vida de una aplicación.

Lo primero que debemos entender es que (a diferencia de un sistema operativo de escritorio) en Android una aplicación no está casada con un proceso. En Android existe una sola aplicación que obtiene el foco y se presenta frente al usuario. Mientras ésta aplicación se encuentra en el frente, las demás aplicaciones entran en estados de pausa, detención o incluso, si la memoria es escasa, Android puede llegar a cerrarlas para liberar recursos y sin estar mediando muchas palabras.

Pero no se asusten, si la aplicación es "asesinada" por Android su estado se almacena para que pueda recuperarse cuando el usuario la ejecute nuevamente. Es en este ínterin de cerrar y abrir aplicaciones en que se liberan los procesos. Debemos ver a un proceso como un simple contenedor desechable para las aplicaciones, no más. Siempre ten presente éste comportamiento al momento de diseñar tus aplicaciones.

El ciclo de vida de una aplicación lo podemos ver en la siguiente imagen.

A continuación describo brevemente cada una de sus fases:

• onCreate(): Se ejecuta la primera vez que la aplicación se muestra. Aquí se pueden realizar toda la inicialización estática (conexiones a bases de datos, creación de interfaces, etc). Recibe un parámetro que puede contener el estado anterior de la aplicación (si fue almacenado correctamente)
• onStart(): Se ejecuta justo antes de que la aplicación se haga visible al usuario
• onRestart(): Llamado justo después que la aplicación ha sido detenida. Justo antes de comenzar de nuevo
• onResume(): Se llamará cuando la aplicación esté lista para interactuar con el usuario. Acá se pueden inicializar cosas como música y animaciones
• onPause(): Se ejecuta justo antes de que la aplicación pase a segundo plano porque otra aplicación ha sido ejecutada. Este método puede ser lo último que vea tu aplicación antes de morir, pues Android puede matar una aplicación pausado sin previo aviso. Es por eso que este es un buen lugar para guardar el estado de tu aplicación.
• onStop(): Es llamado cuando la aplicación ya no es visible al usuario y no se necesitará por un rato. Tal como se indicó en el punto anterior, este método es posible que ni siquiera se ejecute
• onDestroy(): Se llama justo después que la aplicación es destruida. Acá debes hacer el sepelio y esas cosas. Tal como se indicó en el punto anterior, este método es posible que ni siquiera se ejecute

Con toda ésta base teórica podemos decir que estamos listos para empezar a escribir el código de nuestra primera aplicación. Ese será el tema de la próxima entrega.

Para más información sobre éste tema puedes consultar la documentación oficial de Android

¿Cómo desarrollar para Android? - Parte I

Python For Android - Mito o Realidad

Estuve unas cuantas horas investigando sobre la posibilidad de desarrollar con Python sobre Android y a continuación les daré un resumen de los resultados y conclusiones que obtuve.

Acá les dejo el script que usé para probar una parte de los widgets disponibles en la API por si quieren probarlo y echarle un ojo (no me detendré a explicarlo mucho porque el código prácticamente se explica a sí mismo). Además supongo que siguieron los pasos de mi tutorial sobre ¿Cómo desarrollar para Android? y tienen configurado su entorno de desarrollo y saben cómo usar el emulador.

droid = android.Android()

tiempo = droid.dialogGetInput("Escriba la cantidad de tiempo que desea para el demo (10-100)","Tiempo:")
print tiempo

tiempo = int(tiempo[1])
if tiempo < 10: tiempo = 10 elif tiempo > 100:
tiempo = 100

droid.dialogCreateHorizontalProgress('Barra de Progreso', 'Hola, estoy progresando...', tiempo)
droid.dialogShow()
for i in range(tiempo):
time.sleep(0.5)
droid.dialogSetCurrentProgress(i)
droid.dialogDismiss()

droid.dialogCreateSpinnerProgress('Spinner de progreso', 'Mirá, mirá... estoy girando')
droid.dialogShow()
time.sleep(tiempo)
droid.dialogDismiss()

droid.notify('Test de Python' , 'Oh! puedo notificar también')

droid.dialogCreateAlert(title, message)
droid.dialogSetPositiveButtonText('Si')
droid.dialogSetNegativeButtonText('No')
droid.dialogSetNeutralButtonText('Cancelar')
droid.dialogShow()
response = droid.dialogGetResponse().result
print response
droid.makeToast('El resultado de la ejecucion del boton es: %s' %response['which'])

droid.dialogCreateAlert('Selecciona un color')
colores = ('amarillo', 'azul', 'rojo')
droid.dialogSetItems(colores)
droid.dialogShow()
respuesta = droid.dialogGetResponse().result
print respuesta
droid.makeToast('El color seleccionado es: %s' %colores[respuesta['item']])

droid.makeToast('Bueno, chao')

Para correrlo deben instalar algunos paquetes en el cel. Pueden hacerlo con el comando del SDK:

$ adb install /ruta/del/archivo.apk

con los QR que están en la página del proyecto SL4A o con el método que mejor les parezca.

Ok, las cosas a instalar son:

• SL4A
• Python For Android

Luego que las instalen van al dispositivo/emulador y buscan el icono de Python For Android, tap e instalan. Eso tardará unos minutos mientras descarga unas cosas. Al terminar entonces enviamos el script de prueba al cel, podemos usar el comando:

$ adb push /ruta/del/script.py /sdcard/sl4a/scripts/

Eso lo copiará en la carpeta del SL4A. Ahora cuando ejecutemos el Python For Android veremos en la lista de scripts nuestra infame creación, tap en el script y ejecutar. Lo demás es disfrutar las ventanitas y controles :P

Conclusiones

1. La API de SL4A es reducida, es decir si bien está bastante adelantada aún faltan muchas cosas/funciones por implementar.
2. Python For Android a diferencia de lo que pensaba no soporta widgets gráficos en Android, solamente notificaciones, toast y cosas básicas tipo entrada de texto, selección, etc. Así que nos olvidamos de interfaces gráficas ricas en imágenes y esas cosas.
3. Sí existen algunos issues de performance, de hecho un pana que está trabajando duro con Android me dice que los desarrolladores todos los días se matan por tratar de mejorar el rendimiento pues de por si ya es algo lento (hablo de apps nativas). Sin embargo la versión de Python es cross-compiled y corre incluso más rápido que Jython
4. Hay formas de empaquetar scripts en .apk y aunque son algo un poco experimentales funcionan bastante bien (son, digamos, "tweaks" del método de construcción de paquetes con Java)
5. En cuanto a estabilidad no hay mayores issues, se puede usar para aplicaciones de producción

Finalmente puedo decir (muy a mi pesar) que no podemos contar con ésta alternativa para desarrollar aplicaciones ricas en interfaces gráficas, sin embargo es una opción interesante a tener en cuenta cuando madure un poco más. Personalmente le haré seguimiento tipo ninja y esperaré con ansias que en el futuro se puedan crear aplicaciones tan buenas como se hace con Java.

Más información en:

* http://code.google.com/p/android-scripting/
*http://code.google.com/p/android-scripting/wiki/FAQ
* http://code.google.com/p/android-scripting/wiki/Tutorials
* http://code.google.com/p/android-scripting/wiki/ApiReference

¿Cómo desarrollar para Android? - Parte I

Actualmente me he visto en la necesidad de crear aplicaciones para Android y como no había incursionado en ese mundo, he decidido hacer una serie de artículos para documentar todo el proceso.

En ésta primera entrega explicaré los pasos que seguí para poner a punto el entorno de desarrollo. Debo resaltar que las recetas están hechas para Debian GNU/Linux, sin embargo puedes adaptarla a tu distro favorita con unos leves ajustes.

Para los que no están familiarizados con mis tutoriales les recuerdo que todas las instrucciones que comiencen con el caracter $ se ejecutan como usuario normal y las que comiencen con # se ejecutan como superusuario (root), por ejemplo:

$ ls -l (instrucción ejecutada como usuario)
# aptitude update (instrucción ejecutada como root)

Dicho esto comenzamos.

Instalar dependencias

Lo primero que debemos hacer es instalar los paquetes necesarios para el desarrollo, que básicamente son: la máquina virtual de Java (JRE) y el entorno de desarrollo (JDK). En una distribución Debian GNU/Linux bastaría con:

# aptitude update
# aptitude install sun-java6-jdk sun-java6-jre
# aptitude remove gcj-jdk

Si se dan cuenta usamos las implementaciones de SUN y removimos cualquier posible instalación del compilador GNU de Java (gcj) pues en la documentación oficial nos dicen que gcj NO es compatible con Android.

Para más información sobre los requerimientos del sistema visita: http://developer.android.com/sdk/requirements.html

Luego que instalamos los paquetes nos aseguramos de que el sistema seleccione las opciones correctas por defecto de cada ejecutable, pare eso usamos:

# update-alternatives --config javac
# update-alternatives --config java

Y en ambos casos, seleccionamos las opciones de SUN.

Instalar Ant

Ant es una herramienta que nos permite construir aplicaciones Java. En nuestro caso, nos permitirá compilar y construir archivos .apk (los instalables en Android) a partir de nuestro código fuente.

Nos vamos a la página de descargas de Ant, descargamos uno de los archivos comprimidos que se encuentran en la sección "Current Release of Ant" y lo descomprimimos en una carpeta de nuestra preferencia. En mi caso lo hice en /opt y me quedó la carpeta: /opt/apache-ant-1.8.1.

Instalar el Android SDK

Bueno, teniendo las herramientas y dependencias listas, vamos a instalar el entorno de desarrollo de Android. Nos vamos a la página del SDK de Android y descargamos la versión que corresponda a nuestra plataforma. Al igual que con Ant, descomprimimos el archivo en la carpeta de nuestra preferencia. Ésta vez también lo descomprimí en /opt, quedando en la carpeta: /opt/android-sdk-linux_x86.

Ahora editamos el archivo ~/.bashrc para agregar la ruta de los binarios al PATH del sistema y establecer las variables de entorno ANT_HOME y JAVA_HOME. Eso lo logramos agregando las siguientes líneas:

export PATH=${PATH}:/opt/android-sdk-linux_x86/tools
export PATH=${PATH}:/opt/apache-ant-1.8.1/bin
export ANT_HOME=/opt/apache-ant-1.8.1
export JAVA_HOME=/usr/lib/jvm/java-6-sun/jre

Recuerda cambiar las rutas de esas variables por las rutas donde se encuentran tus binarios. Si no sabes muy bien hacía dónde debe apuntar JAVA_HOME puedes ejecutar el comando:

# find / -name "tools.jar" | grep sun

Y entonces agrega la ruta que te arroje.

Nota: Debes cerrar las terminales abiertas y volverlas a abrir para que los cambios en las rutas surtan efecto.

Instalar plataformas de Android

¿Plataformas? ¿De qué me hablas? - Seguramente te estarás haciendo esas preguntas. Las plataformas son las "versiones" de Android disponibles (por ejemplo Android 1.6, Android 2.2) y necesitamos al menos una para poder compilar la aplicación y configurar un Android Virtual Device (AVD) para probarla.

Esto es muy simple, basta con abrir una terminal y ejecutar:

$ android

Nos aparecerá una aplicación (AVD Manager) como la que se muestra a continuación y allí nos vamos a la sección Available Packages, actualizamos el repositorio y seleccionamos la(s) plataforma(s) que deseamos instalar.

Finalmente creamos un nuevo dispositivo virtual en la sección Virtual Device. Hacemos clic en el botón New..., le asignamos un nombre, seleccionamos una plataforma y hacemos clic en Create AVD.

Para probar nuestro flamante dispositivo lo seleccionamos y hacemos clic en Start.... Luego clic en Launch y al cabo de unos segundos tendremos el emulador corriendo una instancia de Android :)

Desarrollo

Ahora viene la parte divertida, crear la aplicación. En las próximas entregas estaré hablando sobre el desarrollo, por los momentos pueden jugar creando un Hello World y pueden leer sobre cómo desarrollar con Eclipse y cómo desarrollar con otros IDEs

Compilar y construir el ejecutable

Luego de que tengamos nuestra aplicación lista debemos crear el instalador. Eso es tan simple como navegar hasta la carpeta raíz del proyecto (código fuente) y ejecutar:

$ ant debug

Si nuestro proyecto se llama "HelloAndroid" esto generará un archivo HelloAndroid-debug.apk y ese será nuestro instalador.

Probar en el emulador

Finalmente, una de las partes más esperadas. ¿Cómo se verá nuestra aplicación en un dispositivo? Pues fácil, en una consola ejecutamos:

$ android

E iniciamos nuestro dispositivo virtual. Luego que el dispositivo esté funcionando ejecutamos en otra consola:

$ adb install /ruta/de/nuestro/instalador/HelloAndroid-debug.apk

Y con eso enviaremos la aplicación al dispositivo. La buscamos en el menú y voilá! A jugar :D

Espero que les haya sido de utilidad éste tutorial. Próximamente seguiré documentando mis travesías en el mundo de Android. Cambio y fuera.

MPD + Sonata: Una combinación perfecta para reproducir música

Lo primero que debo aclarar antes de empezar éste post es que la forma de reproducir música con éstas herramientas es completamente diferente a la tradicional. Si no te interesa reproducir música como un verdadero geek entonces huye y busca otras aplicaciones, éstas no son para tí.

Si eres valiente, continuemos entonces. MPD es un demonio (o sea un servicio) para reproducir música, corre en segundo plano y no tiene interfaz gráfica. De hecho se inicia como cualquier otro servicio de tu equipo (red, hal, udev, etc).

¿Cómo demonios hago para interactuar con él? te preguntarás. Sencillo, está basado en una arquitectura cliente-servidor así que existen aplicaciones que se comunican con él (clientes) y que te permiten manejarlo. Ahí es donde entra Sonata y compañía.

Lo primero que debemos hacer es instalar las dependencias:

# aptitude install mpd mpc sonata

Yo instalaré 2 clientes, Sonata y MPC, porque quiero controlar la reproducción vía SSH desde mi celular xD (sí, sí, muy geek... pero me gusta la comodidad)

Luego vamos a nuestro directorio personal, creamos la carpeta .mpd y dentro de ésta creamos dos carpetas más, playlists y music

$ cd ~
$ mkdir -p .mpd/playlists
$ mkdir -p .mpd/music

Dentro de la carpeta .mpd creamos los archivos mpd.db, mpd.log y mpd.error

$ touch .mpd/mpd.db
$ touch .mpd/mpd.log
$ touch .mpd/mpd.error

Ahora, por cada carpeta de música que tengamos en nuestro sistema creamos un enlace simbólico dentro de music:

$ ln -s /ruta/de_la/carpeta1 .mpd/music
$ ln -s /ruta/de_la/carpeta2 .mpd/music
...

Luego (como root) editamos el archivo de configuración del MPD en /etc/mpd.conf y modificamos las siguientes opciones:

music_directory     /home/tu_usuario/.mpd/music
playlist_directory  /home/tu_usuario/.mpd/playlists
db_file             /home/tu_usuario/.mpd/mpd.db
log_file            /home/tu_usuario/.mpd/mpd.log
error_file          /home/tu_usuario/.mpd/mpd.error

Comentamos la línea de usuario para evitar problemas con los permisos:

#user             "mpd"

Y buscamos el apartado de audio y lo configuramos para ALSA o para PulseAudio:

ALSA:

audio_output {
        type    "alsa"
        name    "My ALSA Device"
}

PulseAudio:

audio_output {
        type    "pulse"
        name    "My PulseAudio Device"
}

Establecemos un mezclador por software descomentando la siguiente línea:

mixer_type "software"

Y voilá! Luego reiniciamos el servicio y creamos la base de datos de tags:

# /etc/init.d/mpd restart --create-db

Ahora desde Sonata (o desde mpc) agregamos las canciones que queramos a la lista y empezamos a disfrutar. Es tan genial ésta combinación que podemos cerrar el Sonata e incluso hasta la sesión gráfica y la música seguirá sonando.

Nos quedará algo tan mínimo como esto:

O en su versión extendida:

Y con unas agradables notificaciones:

Díganme... ¿No es una maravilla? Bueno de aquí en adelante los dejo para que experimenten y se enamoren.

Webcomic: Los FUUU de la vida (I)

Con éste webcomic quiero inaugurar un espacio muy querido y vivido por todos nosotros... Los FUUUU de la vida. He aquí la primera entrega. Enjoy!

Clic en la imagen para agrandar

Respuesta a críticas destructivas sobre Turpial

Me considero una persona tolerante y abierta a las críticas y sugerencias. No hay cosa que me guste más que el feedback de las personas sobre las cosas que hago y más aún sobre Turpial. Sin embargo cosa que no tolero es la mediocridad.

He decidido crear este post para colocar la respuesta que le he dado a @MichelEnLaRed respecto a algunos comentarios que me ha hecho por Twitter sobre Turpial, que en lugar de contribuir al desarrollo del proyecto empañan todo el esfuerzo que duramente se viene haciendo. No pretendo agregar nada a la respuesta que le dí por Twitter, solo la pegaré aquí para unificarla y permitir su mejor lectura.

El comentario que derramó la gota fue el siguiente (sí, hubo 3 o 4 comentarios previos en el mismo tono que dejé pasar por consideración y tolerancia):

Mi respuesta fue:

No había querido responder tus comentarios porque no tenía nada bueno que decirte, pero ya que insistes me tomaré la molestia.

1.- No sé de dónde sacas información para formar juicios de valor sobre mi incapacidad para solventar el cuelgue de Turpial, no estás suscrito a la lista de desarrollo, no te conectas al canal IRC, ni siquiera te veo involucrado como colaborador. Para tu información actualmente estoy usando la API nueva que he diseñado para resolver los problemas de Turpial, pero
está en estado experimental. En el desarrollo de software primero se prueban las cosas antes de lanzarlas al público, son controles de calidad y pruebas q debe pasar la aplicación antes de que pueda ser "usada" por el público en general. Pero veo que no conoces mucho al respecto y por eso lanzas esa sarta de comentarios estériles que en lugar de contribuir desmeritan el fuerte trabajo que he estado haciendo estos últimos días para que ustedes puedan disfrutar de un buen cliente.

2.- Soy una persona con un trabajo de verdad y una vida de verdad, nada me gustaría más que poder dedicarle el 100% de mi tiempo al Turpial, pero lamentablemente eso no me da para comer en estos momentos, así que los pocos instantes libres que me quedan al día son los que invierto en desarrollar el Turpial. Considera eso antes de llamar "incapaz" a otra persona.

3.- Si no te gusta el desempeño de Turpial o te parece que no programo lo suficientemente rápido pues usa otro cliente y ya. Hay centenares de clientes de twitter allí afuera esperando por tí, que no se cuelgan y con programadores realmente "capaces". Turpial es un hobby para mí y la idea es que la comunidad pueda disfrutar, beneficiarse y sentirse a gusto con mi hobby y pues con eso poner en alto el nombre de nuestra patria, hay mucho talento en éste país y debemos sacarle provecho.

No tienes ningún compromiso para usar Turpial, eres libre de escoger... así como el software, completamente libre. Si realmente deseas apoyar Turpial entonces razona y analiza las cosas antes de decirlas, involucrate y colabora, así funciona el software libre y es uno de los principios básicos del socialismo, unión, comunidad, participación...

La mejor forma de cambiar las cosas es formando parte de ellas, no necesitas ser programador para ayudar a Turpial, existen muchas cosas por hacer, eres bienvenido siempre y cuando tus ganas sean de trabajar y de hacer las cosas mejor pero no si lo que tienes es ganas de joder, eso se lo dejamos a los mediocres. Puedes empezar leyendo el archivo de la lista de correos http://smlk.es/6JfSkX, y si gustas únete y aporta tus ideas como un ser racional, pensante e inteligente que eres.

Saludos y gracias por el apoyo

Me disculpo de antemano si hiero algunas susceptibilidades pero las cosas son como son. Las críticas, cuando son constructivas, vienen acompañadas de un planteamiento o una solución.

Mis 2 lochas

Turpial, KumbiaPHP y SigueMiLink trabajando juntos

Hace unos días mi buen amigo Deivinson Tejeda (desarrollador del framework KumbiaPHP) me comentó sobre un nuevo acortador de URLs hecho en España llamado SigueMiLink.

Se preguntarán: ¿Bueno y cuál es la gracia del asunto? Pues lo interesante del asunto es que:

1. El acortador de URLs SigueMiLink está hecho en KumbiaPHP
2. Los creadores de SigueMiLink le plantearon a Deivinson la posibilidad de incluirlo en Turpial
3. Turpial y KumbiaPHP son como proyectos hermanos :) (ambos son Venezolanos)

Al parecer todo se confabuló para crear un círculo de apoyo entre los 3 proyectos y así fue. Ahora me complace anunciar que Turpial soporta a SigueMiLink como nuevo servicio acortador de URLs y que tanto los amigos de SigueMiLink como los de KumbiaPHP apoyan fuertemente a Turpial.

Ojalá se puedan repetir más situaciones como ésta, en la que varios proyectos pueden colaborar entre sí por un fin común... La libertad del software :D