Hola a todos!
Hoy
quisiera estrenarme en el blog con una entrada acerca de algo que a mí me
parece bastante importante antes de comenzar: cómo funciona una app en el
sistema Android. Es probable que muchos de nosotros estemos más que
acostumbrados a otros sistemas operativos como Windows, Mac,… en los cuales
podemos tener varias aplicaciones en funcionamiento en distintas ventanas y
gestionarlas nosotros mismos navegando por cada una de ellas. Sin embargo,
Android es un sistema diseñado ante todo para dispositivos de memoria y batería
limitadas. Es por ello que surge un nuevo concepto: el Ciclo de Vida de la
aplicación.
Antes
de explicar qué es eso del ciclo de vida, vamos a echar un vistazo primero a
las distintas capas en las que se basa la arquitectura del sistema Android.
Cada una de las capas utiliza los servicios proporcionados por las capas
inferiores, quedando dividida en cuatro niveles de jerarquía:
Kernel de Linux: Como podemos observar,
Android se ha creado a partir de los sólidos cimientos que ofrece el sistema
operativo Linux, que además de brindar a los desarrolladores una política de
gratuidad del código también demuestra su buen funcionamiento en dispositivos
de bajo rendimiento. En este nivel se encuentran todos los controladores de
Hardware (pantalla, teclado, audio, Wi-Fi,…), y es aquí donde nosotros podremos
controlar las restricciones de seguridad.
Bibliotecas nativas: Se trata de
archivos con código ejecutable que sólo actúan cuando son llamados por una
aplicación. En ellas se incluye el gestor de superficie (pantalla), Gráficos 2D
y 3D, códecs, SQLite (bases de datos),…
Tiempo de Ejecución Android: Todo el
código que esté escrito en Java es compilado y ejecutado por la Máquina Virutal
Dalvik, pasando de archivos .class o .jar a otros más compactos y eficientes
para dispositivos móviles, los archivos .dex.
Estructura de Aplicaciones: Proporciona
los bloques de construcción de alto nivel, en los que nos vamos a centrar
nosotros al crear nuestra app. Lo componen el Gestor de Actividad (que controla
el ciclo de vida de la aplicación), el Gestor de Recursos (todo aquello que no
es código), Gestor de Ubicación, Gestor de notificaciones,…
Aplicaciones y Widgets: Es todo aquello
que puede interactuar con el usuario, es decir, la aplicación final que ve.
Una
vez tenemos claros los distintos niveles en los que se divide Android, vamos a
adentrarnos un poco más en el concepto de Ciclo de Vida. Dado que nuestra
aplicación convivirá con otras en un dispositivo de memoria limitada, se hace
necesario una gestión del espacio en el buffer por parte del propio sistema
Android. El usuario podrá pasar de una aplicación a otra, o a otra ventana, de
forma que esta última siempre queda en primer plano. Es decir, tal y como vimos
en la entrada de Kike, el usuario puede pasar de una clase Activity a otra. ¿Pero qué pasa con las actividades cuando ya no
están en primer plano?
CICLO
DE VIDA
Cada
vez que se pasa de una actividad a otra, el Gestor de Actividad los deja grabados
en una pila, de forma que si presionas el botón Volver, se puede retornar a la
pantalla anterior. Mientras tanto, dicha actividad pasa a un estado de “pausa”
o de “parado”. Para que al volver a dicha actividad partamos del mismo estado
en que lo dejamos, es necesario que el sistema guarde la información del estado
actual antes de cambiar a otro estado.
Los
distintos estados que forman el Ciclo de Vida de cada una de las actividades se
refleja en el siguiente diagrama:
Aunque
nosotros como desarrolladores no podemos controlar el estado en que se
encuentra nuestra aplicación, sí que podemos recibir notificaciones cada
vez que se cambia de estado mediante el método onXX ().
onCreate
(Bundle): Este método es llamado
cuando la actividad se inicia por primera vez. Puede utilizar el parámetro null, pero si queremos cargar la
información de algún estado previo, utilizaríamos el
parámetro onSaveInstanceState ().
onStart():
Indica que la actividad va a ser mostrada al usuario.
onResume(): Indica que la aplicación va a empezar a
interactuar con el usuario.
onPause(): En este estado la aplicación pasa a un segundo
plano, por lo que debemos guardar previamente el estado en que se encuentra.
onStop(): Es llamada cuando la aplicación ya no es visible
por el usuario y no es necesaria durante un tiempo.
onRestart(): Indica que se está volviendo a mostrar una
aplicación previamente detenida.
onDestroy(): Este método es llamado antes de que la
actividad sea finalizada.
onSaveInstanceState (Bundle): Permite a la actividad guardad
el estado en que se encuentra (por ejemplo, la posición del cursor en un campo
de texto).
Y no quisiera alargarme mucho
más. Bien es cierto que el AS gestiona de forma automática todas estas cosas,
pero creo que no está demás tener unas nociones básicas sobre qué es lo que
ocurre por debajo de aquello que sí que vemos. Y más aún cuando eso de “gestión
automática” normalmente es sinónimo de que tu programa se comporte justo del
modo que a ti no te interesa.
Y eso es todo. Para la próxima me
gustaría enseñaos algún ejemplo de aplicación que nos aclare un poco más cómo
funcionan todos estos programas, en concreto el Eclipse (tener en
cuenta que el AS es el Eclipse+plugins). Estoy siguiendo un libro llamado
“Programación Android”, de Ed Burnette, en el cual pone como ejemplo la
programación de un Sudoku para explicar cada concepto paso por paso. Si queréis
seguirlo conmigo ya os lo iré desglosando poco a poco.
Un saludo!
No hay comentarios:
Publicar un comentario