Android – Página 2 – Planeta UNPLUG

A todos nos ha pasado, estamos trabajando, por error le damos en el teclado a la flecha de arriba y pasa lo peor:

rm -f /home/m1n1m3/descargas/descargdor.sh

Cualquier entra en pánico al darnos cuenta que no teníamos respaldo de este script, pero en estos momentos es cuando mas calma se debe de tener. Analicemos la situación, aun hay procesos usando este archivo, en mi caso aun sigo descargando y compartiendo archivos vía torrents gracias a este script que acabo de eliminar. Lo primero es encontrar el PID para lo cual podemos ejecutar ps y hacer un grep por el nombre del archivo, el resultado tendrá en la primera columna el PID como lo podemos ver aquí:

ps -p | grep -i descargador.sh
30560 pts/3    Ss+    0:00 /bin/bash /home/m1n1m3/descargas/descargdor.sh

El sistema de ficheros /proc mantiene vínculos a los archivos abiertos por procesos dentro de el sub-directorio fd/ (File Descriptor) que a su vez esa anidado dentro de una carpeta con el nombre del PID del proceso y como acabamos de comprobar nuestro script aun se esta ejecutando.

Teniendo en cuenta el PID que obtuvimos anteriormente y ya que sabemos que la estructura de directorios es /proc/<pid>/fd/ podemos determinar que el archivo que acabamos de eliminar esta dentro de /proc/30560/fd/. Para determinar cual de todos es podemos hacer un ls -la y hacerle un grep por el nombre del archivo a la salida del ls -la. Todo esto se debería de ver así:

ls -la /proc/30562/fd/* | grep descargador.sh
/proc/30560/fd/51 -> /home/m1n1m3/descargas/descargador.sh (deleted)

Para recuperar el archivo eliminado solo debemos copiar el archivo dentro de fd/ a donde queramos, en mi caso, lo quiero restaurar, así que ejecutare:

cp /proc/30560/fd/51 /home/m1n1m3/descargas/descargador.sh

Listo, archivo restaurado.

Nota: Esto funciona también en Android

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

Si aun no tienes root de tu teléfono, estas desperdiciando gran parte del potencial de tu dispositivo móvil hoy en día existen muchos mecanismos para lograrlo y el riesgo de ocasionar algún daño permanente se ha disminuido al mínimo.

Asumiendo que ya tienen CyanogenMod en su Android, los pasos para usar tu teléfono móvil como un modem y conectarte a internet son los siguientes:

Click en 'Settings'.
Click en 'Wireless & networks'.
Click en 'Tethering & portable hotspots'.
Selecciona de acuerdo a tus necesidades Wifi o USB.

No deberías de incurrir en cargos adicionales siempre y cuando no sobrepases la cuota mensual de data (en caso de que tengas un limite). Personalmente recomiendo no pasar de 5GB al mes, muchas operadoras ofrecen 'Unlimited Data' pero en realidad tienen un soft-cap de 5GB y cualquier cosa por encima le hacen throtle o investigan que tipo de trafico es.

Una cosa que nunca me gusto de Android y de hecho fue una de las cosas que mas me costo acostumbrarme fue la resolución de la pantalla, los iconos y letras inmensas, me parecía un desperdicio de pantalla el no poder cambiarle la densidad al LCD, en especial cuando tienes 11 centímetros (4.3 pulgadas). Luego de rootear el teléfono me puse a buscar la forma de alterar esto y conseguí una app que se llama LCDDensity for Root.

El programa funciona de maravilla, excepto que en el nightly build que estoy usando de CyanogenMod la barra del ADW.Launcher se muestra descontinua y desalineada si se asigna el valor de 190 o por debajo de este. Conseguí un script que usando el terminal de android nos permite asignar un valor arbitrario así que me propuse buscar cual era el valor entre 190 y 200 en el que la barra no se distorsionaba y luego de un par de intentos di con el numero 192. Este es el script:

#!/system/bin/sh
#Version 0.1
#Created by lithid

mount -o rw,remount /system
cd /system
sed "s/ro.sf.lcd_density = .*/ro.sf.lcd_density = $1/g" build.prop > tmp

mv tmp build.prop
echo -n "Do you want to reboot now? (y or n) > "
read list
if [ "$list" = "n" ] || [ "$list" = "N" ]
  then echo "No Eh? Must not wanna see your changes."
  mount -o ro,remount /system
  exit 1
elif [ "$list" = "y" ] || [ "$list" = "Y" ]; then echo "Rebooting Device"
  sleep 1 reboot
else
  echo "That is not a yes or a no"
  echo "Leaving"
  mount -o ro,remount /system
  exit 1
fi
exit

Este script fue escrito por @lithid y publicado en los foros de CyanogenMod.

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:

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

La API de SL4A es reducida, es decir si bien está bastante adelantada aún faltan muchas cosas/funciones por implementar.
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.
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
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)
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

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.

Después de un par de días con problemas tras un update de Touiteur encontré la solución para cuando el Google Play Store también conocido como Android Market hace crash al uno intentar cancelar una descarga.

Touiteur funcionaba bien pero segun el Google Play Store mostraba que aun se estaba descargando una versión nueva, decidí cancelarla e inmediatamente me salio un mensaje de error del market que debía cerrarse. Desinstalando la aplicación y haciendo logout y login en google talk no hicieron ninguna diferencia excepto que ahora no tengo la aplicación instalada y no la puedo instalar.

La solución es limpiar el cache de esa aplicación, la data local de esa aplicación. Para lograr esto solo debemos ir a Settings -->*Applications* -->*Manage Applications* -->*All* -->*Market* -->*Clear Data* y por ultimo luego forzamos la aplicación para que se sierre como se puede ver en estas imágenes:

[gallery link="file" order="DESC"]

Si tienes problemas específicamente actualizando aplicaciones que ya tienes instaladas o no te aparecen disponibles algunas aplicaciones que antes si aparecían disponibles, no dejes de leer: `Dispositivo no soportado tras actualización del Android Market - This item is not compatible with your device`_

Logos de Youtube y Android Google ha liberado la nueva aplicación de YouTube para el Android liberándola de los ROMs. Lo bueno de esto es que podemos esperar que nuevas funcionalidades sean publicadas mas seguido. El problema viene cuando intentas instalar la versión del Google Play Store. Como ya existe la versión del ROM el Google Play Store también conocido como Android Market no la puede remplazar/actualizar por que la partición /system esta montada como read only.

La solución:

Abrir la aplicación Terminal Emulator y ejecutamos esto:

cd /system su mount -o remount,rw /system rm -Rf YouTube.* reboot

Para que esto funcione debes de tener rooteado tu Android, luego de que se reinicie el teléfono regresas al market e instalas la aplicación sin problema.

Nota: Esto funciono en mi HTC Evo con CyanogenMod 6.

Los zombis también pueden estar en el NSLU2

Un proceso zombi es un proceso que ha completado su ejecución pero aun tiene una entrada en la tabla de procesos. Esta entrada aun es necesitada para permitir la lectura del estado de su estado de salida. El Termino zombi se deriva de la definición de un muerto viviente (se acuerdan de esa película?). Para ponerlo en términos simples y un poco mas técnicos, un proceso hijo ha terminado pero aun no se ha eliminado de la tabla de procesos y el comando kill no tiene efectos sobre él.

Identificarlos es fácil, podemos ejecutar el comando ps y buscamos cuales procesos tienen una "z" en la columna "STAT". Los procesos zombi que permanecen por un periodo mas que corto por lo general es señal de un Bug en el proceso padre. Ahora bien, si el zombi aun existe después de que el proceso padre ha terminado esto por lo general indica un bug en el sistema operativo.

[caption id="attachment_231" align="aligncenter" width="700" caption="La salida de el comando top que muestra donde están los zombis"][/caption]

Un procesos zombi no es un problema tan grave, el problema se agrava si el computador va a ser sometido a fuertes cargas pues puede ser que se multipliquen. A pesar de que los zombis no consumen memoria un incremento acelerado de estos podría traer consecuencias a la hora de que el sistema operativo se le acaben los PID a asignar.

Una vez que el padre haya matado el zombi el proceso ID (PID) y la entrada en la tabla de procesos puede ser reutilizada, pero si este falla, el zombi permanece en la tabla de procesos.

Para eliminar un zombi del sistema, se le debe enviar la señal SIGCHLD al padre usando el comando kill. En caso de que el padre se no pueda eliminar el zombi de la tabla de procesos podríamos intentar matando el proceso padre. Algo que debemos tomar en cuenta es que cuando un proceso pierde a su padre, 'init' pasar a ser su nuevo padre y este se encarga de limpiar periódicamente la tabla de procesos de los zombis cuyos padres sean init.

Usando `du` podemos encontrar los directorios y archivos mas grande dentro de un directorio. el siguiente ejemplo muestra como listar los 10 archivos y carpetas mas grande dentro del directorio 'HOME'

du -a ~/ | sort -n -r | head -n 10

En el script de arriba, lo que estamos haciendo es listar todos los archivos y directorios que están en el directorio donde nos encontramos junto a su tamaño, luego los ordenamos numéricamente y de forma inversa y finalmente elegimos los últimos 10.

Con `find` podemos conseguir los 10 archivos mas grandes recursivamente dentro de un directorio.

find ~/ -type f -exec ls -ls {} \; | awk '{print $6"\t"$9}' | sort -k1 -n -r | head -n 10

Este script busca todos los archivos dentro de nuestro home, y los pasa por el comando ls -ls que los va a listar mostrando su tamaño. El resto de esta linea solo toma los campos seis y nueve pertenecientes a el tamaño en bloques y el nombre. Al igual que el script anterior el ultimo segmento de este script ordena numéricamente la salida y de forma inversa para luego tomar los primeros diez resultados.