Upload
osiris198930123
View
577
Download
3
Embed Size (px)
DESCRIPTION
Curso Android Studio
Citation preview
1
Curso Programacin Android
Conceptos Generales (Android Studio) [Nuevo!]
1. Entorno de desarrollo Android (Android Studio) [Nuevo!] 2. Estructura de un proyecto Android (Android Studio) [Nuevo!] 3. Componentes de una aplicacin Android (Android Studio) [Nuevo!] 4. Desarrollando una aplicacin Android sencilla (Android Studio) [Nuevo!]
Interfaz de Usuario en Android
1. Interfaz de usuario en Android: Layouts [v3] [Actualizado] 2. Controles bsicos (I): Botones [v3] [Actualizado] 3. Controles bsicos (II): Texto e Imgenes [v3] [Actualizado] 4. Controles bsicos (III): Checkbox y Radiobutton [v3] [Actualizado] 5. Controles de seleccin (I): Listas desplegables (Spinner) [v3] [Actualizado] 6. Controles de seleccin (II): Listas (ListView) [v3] [Actualizado] 7. Controles de seleccin (III): Listas optimizadas (ViewHolder) [v3] [Actualizado] 8. Controles de seleccin (IV): Tablas (GridView) [v3] [Actualizado] 9. Controles de seleccin (V): RecyclerView [Nuevo!] 10. Interfaz de Usuario en Android: CardView [Nuevo!] 11. Interfaz de usuario en Android: Controles personalizados (I) [v3] [Actualizado] 12. Interfaz de usuario en Android: Controles personalizados (II) [v3] [Actualizado] 13. Interfaz de usuario en Android: Controles personalizados (III) [v3] [Actualizado] 14. Interfaz de usuario en Android: Pestaas (Tabs) [v3] 15. Interfaz de usuario en Android: Fragments [v3] 16. Interfaz de usuario en Android: ActionBar (I): Introduccin [v3] 17. Interfaz de usuario en Android: ActionBar (II): Tabs [v3] 18. Interfaz de usuario en Android: ActionBar Compat 19. Interfaz de usuario en Android: Navigation Drawer
Mens en Android
1. Mens en Android (I): Mens y Submens bsicos [v3] 2. Mens en Android (II): Mens Contextuales [v3] 3. Mens en Android (III): Opciones avanzadas [v3]
Widgets en Android
1. Interfaz de usuario en Android: Widgets (I) [v3] 2. Interfaz de usuario en Android: Widgets (II) [v3]
Gestin de Preferencias en Android
1. Preferencias en Android I: SharedPreferences [v3] 2. Preferencias en Android II: PreferenceActivity [v3]
Bases de Datos en Android
1. Bases de datos en Android (I): Primeros pasos con SQLite [v3] 2. Bases de datos en Android (II): Insercin, actualizacin y eliminacin de registros [v3] 3. Bases de datos en Android (III): Consulta y recuperacin de registros [v3]
Ficheros en Android
1. Ficheros en Android (I): Memoria Interna [v3]
2
2. Ficheros en Android (II): Memoria Externa (Tarjeta SD) [v3]
Tratamiento de XML en Android
1. Tratamiento de XML en Android (I): SAX [v3] 2. Tratamiento de XML en Android (II): SAX simplicado [v3] 3. Tratamiento de XML en Android (III): DOM [v3] 4. Tratamiento de XML en Android (IV): XmlPull [v3] 5. Alternativas para leer y escribir XML (y otros ficheros) en Android [v3]
Localizacin Geogrfica en Android
1. Localizacin geogrfica en Android (I) [v3] 2. Localizacin geogrfica en Android (II) [v3]
Content Providers en Android
1. Content Providers en Android (I): Construccin [v3] 2. Content Providers en Android (II): Utilizacin [v3]
Notificaciones en Android
1. Notificaciones en Android (I): Toast [v3] 2. Notificaciones en Android (II): Barra de Estado [v3] 3. Notificaciones en Android (III): Dilogos [v3]
Acceso a Servicios Web en Android
1. Servicios Web SOAP en Android (1/2) [v3] 2. Servicios Web SOAP en Android (2/2) [v3] 3. Servicios Web REST en Android (1/2) [v3] 4. Servicios Web REST en Android (2/2) [v3]
Tareas en segundo plano en Android
1. Tareas en segundo plano I: Thread y AsyncTask [v3] 2. Tareas en segundo plano II: IntentService [v3]
Depuracin de aplicaciones en Android
1. Depuracin en Android: Logging [v3]
Google Play Services
I. Introduccin y Preparativos
1. Introduccin y Preparativos II. Mapas en Android
1. Mapas en Android API v1 (I): Preparativos y ejemplo bsico [Obsoleto. Ver API v2] 2. Mapas en Android API v1 (II): Control MapView [Obsoleto. Ver API v2] 3. Mapas en Android API v1 (III): Overlays (Capas) [Obsoleto. Ver API v2] 4. Mapas en Android (Google Maps Android API v2) I [v3] [Actualizado] 5. Mapas en Android (Google Maps Android API v2) II [v3] [Actualizado] 6. Mapas en Android (Google Maps Android API v2) III [v3] [Actualizado]
III. Notificaciones Push en Android Google Cloud Messaging (GCM / C2DM) 1. Introduccin [v3] 2. Implementacin del Servidor [v3] 3. Implementacin del Cliente Android [v3] [Ver nueva versin] 4. Implementacin del Cliente Android (Nueva Versin)
IV. Integracin con Google+
1. Inicio de Sesin con Google+ (Sign-In)
3
2. Acceso a datos del perfil y crculos
Conceptos Generales (Android Studio)
Entorno de desarrollo Android (Android Studio)
by Sgoliver on 20/12/2014 in Android, Programacin
El ritmo de actualizaciones de Android Studio es bastante alto, por lo que algunos detalles
de este artculo pueden no ajustarse exactamente a la ltima versin de la aplicacin. Este
artculo se encuentra actualizado para la versin de Android Studio 1.0.2
Para empezar con este Curso de Programacin Android, vamos a describir los pasos bsicos
para disponer en nuestro PC del entorno y las herramientas necesarias para comenzar a
programar aplicaciones para la plataforma Android.
No voy a ser exhaustivo, ya que existen muy buenos tutoriales sobre la instalacin de Java,
Android Studio y el SDK de Android, incluida la documentacin oficial de la plataforma,
por lo que tan slo enumerar los pasos necesarios de instalacin y configuracin, y
proporcionar los enlaces a las distintas herramientas. Vamos all.
Paso 1. Descarga e instalacin de Java.
Si an no tienes instalado ninguna versin del JDK (Java Development Kit) puedes
descargarla desde la web de Oracle.
Aunque ya est disponible Java 8, para el desarrollo en Android nos seguiremos
quedando por ahora con Java 7. En el momento de escribir este manual la reversin ms
reciente de esta serie es laversin 7 update 71, que deberemos descargar para nuestra
versin concreta del sistema operativo. Por ejemplo, para Windows 64 bits descargaremos
el ejecutable marcado como Windows x64 cuyo nombre de fichero es jdk-7u71-
windows-x64.exe.
4
La instalacin no tiene ninguna dificultad, se trata de un instalador estndar de Windows
donde tan slo hay que aceptar, pantalla por pantalla, las opciones que ofrece por defecto.
El siguiente paso es opcional, pero puede evitarnos algn que otro problema en el futuro.
Crearemos una nueva variable de entorno llamada JAVA_HOME y cuyo valor sea la ruta
donde hemos instalado el JDK, por ejemplo C:\Program Files\Java\jdk1.7.0_71. Para
aadir una variable de entorno del sistema en Windows podemos acceder al Panel de
Control / Sistema y Seguridad / Sistema / Configuracin avanzada del sistema / Opciones
Avanzadas / Variables de entorno.
Paso 2. Descarga e instalacin de Android Studio y el SDK de Android.
Descargaremos Android Studio accediendo a la web de desarrolladores de Android, y
dirigindonos a la seccin dedicada al SDK de la plataforma. Descargaremos el instalador
correspondiente a nuestro sistema operativo pulsando el botn verde Download Android
Studio y aceptando en la pantalla siguiente los trminos de la licencia.
Para instalar la aplicacin ejecutamos el instalador descargado (en mi caso el fichero se
llama android-studio-bundle-135.1641136.exe) y seguimos el asistente aceptando todas
5
las opciones seleccionadas por defecto. Durante el proceso se instalar el SDK de Android,
los componentes adicionales para el desarrollo sobre Android 5.0, un dispositivo virtual (o
AVD, ms adelante veremos lo que es esto) preconfigurado para dicha versin de
Android, y por supuesto el entorno de desarrollo Android Studio.
Como puede verse en la imagen anterior, tambin se instalar y configurar durante la
instalacin (si tu PC es compatible) el llamado Intel Hardware Accelerated Execution
Manager (o HAXM), que nos ayudar a mejorar el rendimiento del emulador de
Android, ms adelante hablaremos de esto. En un paso posterior del instalador se podr
indicar adems la cantidad de memoria que reservaremos para este componente (se puede
dejar seleccionada la opcin por defecto):
Durante la instalacin tendremos que indicar tambin las rutas donde queremos instalar
tanto Android Studio como el SDK de Android. Para evitar posibles problemas futuros mi
recomendacin personal es seleccionar rutas que no contengan espacios en blanco.
6
Una vez finalizada la instalacin se iniciar automticamente Android Studio. Es posible
que nos aparezca en este momento un cuadro de dilogo consultando si queremos
reutilizar la configuracin de alguna versin anterior del entorno. Para realizar una
instalacin limpia seleccionaremos la opcin I do not have a previous version.
Durante la primera ejecucin aparecer adems el asistente de inicio que se encarga de
descargar e instalar/actualizar algunos componentes importantes del SDK de Android (si
existieran).
Paso 3. Actualizacin de Android Studio.
Este paso tambin es opcional, aunque recomendable. Tras finalizar el asistente de inicio
nos aparecer la pantalla de bienvenida de Android Studio:
7
Podemos comprobar si existe alguna actualizacin de Android Studio pulsando el enlace
situado en la parte inferior de la pantalla de bienvenida (Check for updates now), lo que nos
mostrar informacin sobre la ltima actualizacin disponible (si existe) y nos permitir
instalarla pulsando el botn Update and restart. En mi caso, estaba disponible como
actualizacin la versin 1.0.2:
Tras la actualizacin, Android Studio se reiniciar y volveremos a aparecer en la pantalla
de bienvenida.
Paso 4. Configuracin inicial de Android Studio.
Lo siguiente que haremos antes de empezar a utilizar el IDE ser asegurarnos de que estn
correctamente configuradas las rutas a los SDK de Java y Android.
Para ello pulsaremos la opcin Configure de la pantalla de bienvenida, tras sta
accederemos a Project Defaults y despus a Project Structure. En la ventana de
opciones que aparece revisaremos el apartado SDK Location asegurndonos de que
tenemos correctamente configuradas las rutas al JDK y al SDK de Android. A continuacin
muestro la configuracin en mi caso, aunque puede variar segn las rutas que hayis
utilizado para instalar los distintos componentes.
8
Tras la revisin pulsamos el botn OK para aceptar la configuracin y volvemos al men
de la pantalla de bienvenida de Android Studio.
Paso 5. Instalar/actualizar componentes del SDK de Android.
El siguiente paso ser actualizar algunos componentes del SDK de Android e instalar otros
adicionales que nos pueden ser necesarios/tiles para el desarrollo de nuestras aplicaciones.
Para ello accederemos al men Configure / SDK Manager de la pantalla de bienvenida,
lo que nos permitir acceder al SDK Manager de Android. Con esta herramienta podremos
instalar, desinstalar, o actualizar todos los componentes disponibles como parte del SDK de
Android.
Los componentes principales que, como mnimo, deberemos instalar/actualizar sern los
siguientes:
1. Android SDK Tools 2. Android SDK Platform-tools 3. Android SDK Build-tools (por ahora la versin ms reciente) 4. Una o ms versiones de la plataforma Android 5. Android Support Repository (extras)
9
6. Google Play Services (extras) 7. Google Repository (extras)
El punto 4 es uno de los ms importantes, ya que contiene los componentes y libreras
necesarias para desarrollar sobre cada una de las versiones concretas de Android. As, si
queremos probar nuestras aplicaciones por ejemplo sobre Android 2.2 y 4.4 tendremos que
descargar sus dos plataformas correspondientes. Mi consejo personal es siempre instalar al
menos 2 plataformas: la correspondiente a la ltima versin disponible de Android, y la
correspondiente a la mnima versin de Android que queremos que soporte nuestra
aplicacin, esto nos permitir probar nuestras aplicaciones sobre ambas versiones para
asegurarnos de que funciona correctamente. En este curso nos centraremos en las versiones
4.x y 5.x de Android. Intentar que todo lo expuesto sea compatible al menos desde la
versin 4.0.3 (API 15) en adelante, por lo que en nuestro caso instalaremos, adems de la
reciente versin 5.0 (API 21), alguna plataforma de la versin 4, por ejemplo la 4.4.2 (API
19).
A modo de referencia, en mi caso seleccionar los siguientes componentes/versiones
(algunos pueden estar ya instalados):
1. Android SDK Tools (Rev. 24.0.2) 2. Android SDK Platform-tools (Rev. 21) 3. Android SDK Build-tools (Rev. 21.1.2) 4. Android 5.0.1 (API 21) 1. SDK Platform 2. Google APIs 3. Google APIs Intel x86 Atom System Image 5. Android 4.4.2 (API 19) 1. SDK Platform 2. Google APIs (x86 System Image) 6. Extras 1. Android Support Repository (Rev. 11) 2. Google Play Services (Rev. 22) 3. Google Repository (Rev. 15)
Si nuestro PC no fuera compatible con HAXM, podemos sustituir los componentes 4.3 y
5.2 por los dos siguientes (la funcionalidad ser la misma aunque el rendimiento ser ms
lento):
4.3. Google APIs ARM EABI v7a System Image
5.2. Google APIs (ARM Systema Image)
Seleccionaremos los componentes que queremos instalar o actualizar, pulsaremos el botn
Install packages, aceptaremos las licencias correspondientes, y esperaremos a que
10
finalice la descarga e instalacin. Una vez finalizado el proceso es recomendable cerrar el
SDK Manager y reiniciar Android Studio.
Con este paso ya tendramos preparadas todas las herramientas necesarias para comenzar a
desarrollar aplicaciones Android. En prximos apartados veremos como crear un nuevo
proyecto, la estructura y componentes de un proyecto Android, y crearemos y probaremos
sobre el emulador una aplicacin sencilla para poner en prctica todos los conceptos
aprendidos.
Estructura de un proyecto Android (Android Studio)
by Sgoliver on 28/12/2014 in Android, Programacin
El ritmo de actualizaciones de Android Studio es bastante alto, por lo que algunos detalles
de este artculo pueden no ajustarse exactamente a la ltima versin de la aplicacin. Este
artculo se encuentra actualizado para la versin de Android Studio 1.0.2
Seguimos con el Curso de Programacin Android. Para empezar a comprender cmo se
construye una aplicacin Android vamos a crear un nuevo proyecto Android en Android
Studio y echaremos un vistazo a la estructura general del proyecto creado por defecto.
Para crear un nuevo proyecto ejecutaremos Android Studio y desde la pantalla de
bienvenida pulsaremos la opcin Start a new Android Studio project para iniciar el
asistente de creacin de un nuevo proyecto.
Si ya habamos abierto anteriormente Android Studio es posible que se abra directamente la
aplicacin principal en vez de la pantalla de bienvenida. En ese caso accederemos al men
File / New project para crear el nuevo proyecto.
11
El asistente de creacin del proyecto nos guiar por las distintas opciones de creacin y
configuracin de un nuevo proyecto Android.
En la primera pantalla indicaremos, por este orden, el nombre de la aplicacin, el dominio
de la compaa, y la ruta donde crear el projecto. El segundo de los datos indicados tan slo
se utilizar como paquete de nuestras clases java. As, si por ejemplo indicamos como en
mi caso android.sgoliver.net, el paquete java principal utilizado para mis clases
ser net.sgoliver.android.holausuario. En tu caso puedes utilizar cualquier otro dominio.
En la siguiente pantalla del asistente configuraremos las plataformas y APIs que va a
utilizar nuestra aplicacin. Nosotros nos centraremos en aplicaciones para telfonos y
tablets, en cuyo caso tan slo tendremos que seleccionar la API mnima (es decir, la versin
mnima de Android) que soportar la aplicacin. Como ya indiqu en el captulo sobre
la instalacin del entorno de desarrollo, en este curso nos centraremos en Android 4.0.3
como versin mnima (API 15).
La versin mnima que seleccionemos en esta pantalla implicar que nuestra aplicacin se
pueda ejecutar en ms o menos dispositivos. De esta forma, cuanto menor sea sta, a ms
dispositivos podr llegar nuestra aplicacin, pero ms complicado ser conseguir que se
ejecute correctamente en todas las versiones de Android. Para hacernos una idea del
nmero de dispositivos que cubrimos con cada versin podemos pulsar sobre el enlace
Help me choose, que mostrar el porcentaje de dispositivos que ejecutan actualmente
cada versin de Android. Por ejemplo, en el momento de escribir este artculo, si
12
seleccionamos como API mnima la 15 conseguiramos cubrir un 89.7% de los dispositivos
actuales. Como informacin adicional, si pulsamos sobre cada versin de Android en esta
pantalla podremos ver una lista de las novedades introducidas por dicha versin.
En la siguiente pantalla del asistente elegiremos el tipo de actividad principal de la
aplicacin. Entenderemos por ahora que una actividad es una ventana o pantalla de la
aplicacin. Para empezar seleccionaremos BlankActivity, que es el tipo ms sencillo.
Por ltimo, en el siguiente paso del asistente indicaremos los datos asociados a esta
actividad principal que acabamos de elegir, indicando el nombre de su clase java asociada
(Activity Name) y el nombre de su layout xml (algo as como la interfaz grfica de la
actividad, lo veremos ms adelante), su ttulo, y el nombre del recurso XML
correspondiente a su men principal. No nos preocuparemos mucho por ahora de todos
estos datos por lo que podemos dejar todos los valores por defecto. Ms adelante en el
curso explicaremos cmo y para qu utilizar estos elementos.
13
Una vez configurado todo pulsamos el botn Finish y Android Studio crear por nosotros
toda la estructura del proyecto y los elementos indispensables que debe contener. Si todo va
bien aparecer la pantalla principal de Android Studio con el nuevo proyecto creado.
En ocasiones, la versin actual de Android Studio no realiza correctamente esta primera
carga del proyecto y es posible que os encontris con el error que veis en la siguiente
imagen (Rendering Problems). Para solucionarlo no tenis ms que cerrar la ventana
del editor grfico (1) y volverla a abrir pulsando sobre el fichero activity_main.xml que
podis ver en el explorador de la parte izquierda (2).
En la parte izquierda, podemos observar todos los elementos creados inicialmente para
el nuevo proyecto Android, sin embargo por defecto los vemos de una forma un tanto
peculiar que podra llevarnos a confusin. Para entender mejor la estructura del proyecto
vamos a cambiar momentneamente la forma en la que Android Studio nos la muestra. Para
ello, pulsaremos sobre la lista desplegable situada en la parte superior izquierda, y
cambiaremos la vista de proyecto a Project.
14
Tras hacer esto, la estructura del proyecto cambia un poco de aspecto y pasa a ser como se
observa en la siguiente imagen:
En los siguientes apartados describiremos los elementos principales de esta estructura.
Lo primero que debemos distinguir son los conceptos de proyecto y mdulo. La
entidad proyecto es nica, y engloba a todos los dems elementos. Dentro de un proyecto
podemos incluir varios mdulos, que pueden representar aplicaciones distintas, versiones
diferentes de una misma aplicacin, o distintos componentes de un sistema (aplicacin
mvil, aplicacin servidor, libreras, ). En la mayora de los casos, trabajaremos con un
proyecto que contendr un slo mdulo correspondiente a nuestra aplicacin principal. Por
15
ejemplo en este caso que estamos creando tenemos el proyecto android-hola-usuario que
contiene al mdulo app que contendr todo el software de la aplicacin de ejemplo.
A continuacin describiremos los contenidos principales de nuestro mdulo principal.
Carpeta /app/src/main/java
Esta carpeta contendr todo el cdigo fuente de la aplicacin, clases auxiliares, etc.
Inicialmente, Android Studio crear por nosotros el cdigo bsico de la pantalla
(actividad o activity) principal de la aplicacin, que recordemos que en nuestro caso
era MainActivity, y siempre bajo la estructura del paquete java definido durante la creacin
del proyecto.
Carpeta /app/src/main/res/
Contiene todos los ficheros de recursos necesarios para el proyecto: imgenes, layouts,
cadenas de texto, etc. Los diferentes tipos de recursos se pueden distribuir entre las
siguientes subcarpetas:
Carpeta Descripcin
/res/drawable/ Contiene las imgenes [y otros elementos grficos] usados
en por la aplicacin. Para poder definir diferentes recursos
dependiendo de la resolucin y densidad de la pantalla del
dispositivo se suele dividir en varias subcarpetas:
/drawable (recursos independientes de la densidad)
/drawable-ldpi (densidad baja)
16
/drawable-mdpi (densidad media)
/drawable-hdpi (densidad alta)
/drawable-xhdpi (densidad muy alta)
/drawable-xxhdpi (densidad muy muy alta :)
/res/layout/ Contiene los ficheros de definicin XML de las diferentes
pantallas de la interfaz grfica. Para definir
distintos layouts dependiendo de la orientacin del
dispositivo se puede dividir tambin en subcarpetas:
/layout (vertical)
/layout-land (horizontal)
/res/anim/
/res/animator/
Contienen la definicin de las animaciones utilizadas por la
aplicacin.
/res/color/ Contiene ficheros XML de definicin de colores
segn estado.
/res/menu/ Contiene la definicin XML de los mens de la aplicacin.
/res/xml/ Contiene otros ficheros XML de datos utilizados por la
aplicacin.
/res/raw/ Contiene recursos adicionales, normalmente en formato
distinto a XML, que no se incluyan en el resto de carpetas
de recursos.
/res/values/ Contiene otros ficheros XML de recursos de la aplicacin,
como por ejemplo cadenas de texto (strings.xml), estilos
(styles.xml), colores (colors.xml), arrays de valores
(arrays.xml), tamaos (dimens.xml), etc.
No todas estas carpetas tienen por qu aparecer en cada proyecto Android, tan slo las que
se necesiten. Iremos viendo durante el curso qu tipo de elementos se pueden incluir en
cada una de ellas y cmo se utilizan.
Como ejemplo, para un proyecto nuevo Android como el que hemos creado, tendremos por
defecto los siguientes recursos para la aplicacin:
17
Como se puede observar, existen algunas carpetas en cuyo nombre se incluye un sufijo
adicional, como por ejemplo values-w820dp. Estos, y otros sufijos, se emplean para
definir recursos independientes para determinados dispositivos segn sus caractersticas. De
esta forma, por ejemplo, los recursos incluidos en la carpeta values-w820dp se aplicaran
slo a pantallas con ms de 820dp de ancho, o los incluidos en una carpeta
llamada values-v11 se aplicaran tan slo a dispositivos cuya versin de Android sea la
3.0 (API 11) o superior. Al igual que los sufijos -w y v existen otros muchos para
referirse a otras caractersticas del terminal, puede consultarse la lista completa en
la documentacin oficial del Android.
Entre los recursos creados por defecto cabe destacar los layouts, en nuestro caso slo
tendremos por ahora el llamado activity_main.xml, que contienen la definicin de la
interfaz grfica de la pantalla principal de la aplicacin. Si hacemos doble clic sobre este
fichero Android Studio nos mostrar esta interfaz en su editor grfico, y como podremos
comprobar, en principio contiene tan slo una etiqueta de texto con el mensaje Hello
World!.
18
Pulsando sobre las pestaas inferiores Design y Text podremos alternar entre el editor
grfico (tipo arrastrar-y-soltar), mostrado en la imagen anterior, y el editor XML que se
muestra en la imagen siguiente:
Durante el curso no utilizaremos demasiado el editor grfico, sino que modificaremos la
interfaz de nuestras pantallas manipulando directamente su fichero XML asociado. Esto en
principio puede parecer mucho ms complicado que utilizar el editor grfico [no es nada
complicado en realidad], pero por el contrario nos permitir aprender muchos de los
entresijos de Android ms rpidamente.
Fichero /app/src/main/AndroidManifest.xml
Contiene la definicin en XML de muchos de los aspectos principales de la aplicacin,
como por ejemplo su identificacin (nombre, icono, ), sus componentes (pantallas,
servicios, ), o los permisos necesarios para su ejecucin. Veremos ms adelante ms
detalles de este fichero.
Fichero /app/build.gradle
Contiene informacin necesaria para la compilacin del proyecto, por ejemplo la versin
del SDK de Android utilizada para compilar, la mnima versin de Android que soportar
la aplicacin, referencias a las libreras externas utilizadas, etc. Ms adelante veremos
tambin ms detalles de este fichero.
19
En un proyecto pueden existir varios ficheros build.gradle, para definir determinados
parmetros a distintos niveles. Por ejemplo, en nuestro proyecto podemos ver que existe un
fichero build.gradle a nivel de proyecto, y otro a nivel de mdulo dentro de la carpeta /app.
El primero de ellos definir parmetros globales a todos los mdulos del proyecto, y el
segundo slo tendr efecto para el mdulo correspondiente.
Carpeta /app/libs
Puede contener las libreras java externas (ficheros .jar) que utilice nuestra aplicacin.
Normalmente haremos referencia a dichas librera en el fichero build.gradle descrito en el
punto anterior, de forma que entren en el proceso de compilacin de nuestra aplicacin.
Veremos algn ejemplo ms adelante.
Carpeta /app/build/
Contiene una serie de elementos de cdigo generados automticamente al compilar el
proyecto. Cada vez que compilamos nuestro proyecto, la maquinaria de compilacin de
Android genera por nosotros una serie de ficheros fuente java dirigidos, entre otras muchas
cosas, al control de los recursos de la aplicacin.Importante: dado que estos ficheros se
generan automticamente tras cada compilacin del proyecto es importante que no se
modifiquen manualmente bajo ninguna circunstancia.
A destacar sobre todo el fichero que aparece desplegado en la imagen anterior, llamado
R.java, donde se define la clase R. Esta clase R contendr en todo momento una serie de
constantes con los identificadores (ID) de todos los recursos de la aplicacin incluidos en la
carpeta /app/src/main/res/, de forma que podamos acceder fcilmente a estos recursos desde
nuestro cdigo a travs de dicho dato. As, por ejemplo, la
constante R.layout.activity_main contendr el ID del layout activity_main.xml contenido
en la carpeta /app/src/main/res/layout/.
20
Y con esto todos los elementos principales de un proyecto Android. No pierdas de vista este
proyecto de ejemplo que hemos creado ya que lo utilizaremos en breve como base para
crear nuestra primera aplicacin. Pero antes, en el siguiente apartado hablaremos de los
componentes software principales con los que podemos construir una aplicacin Android.
Componentes de una aplicacin Android
by Sgoliver on 11/08/2010 in Android, Programacin
En el artculo anterior del curso vimos la estructura de un proyecto Android y aprendimos
dnde colocar cada uno de los elementos que componen una aplicacin, tanto elementos de
software como recursos grficos o de datos. En ste nuevo artculo vamos a centrarnos
especficamente en los primeros, es decir, veremos los distintos tipos de componentes de
software con los que podremos construir una aplicacin Android.
En Java o .NET estamos acostumbrados a manejar conceptos como ventana, control,
eventos o servicios como los elementos bsicos en la construccin de una aplicacin.
Pues bien, en Android vamos a disponer de esos mismos elementos bsicos aunque con un
pequeo cambio en la terminologa y el enfoque. Repasemos los componentes principales
que pueden formar parte de una aplicacin Android [Por claridad, y para evitar confusiones
al consultar documentacin en ingls, intentar traducir lo menos posible los nombres
originales de los componentes].
Activity
Las actividades (activities) representan el componente principal de la interfaz grfica de
una aplicacin Android. Se puede pensar en una actividad como el elemento anlogo a una
ventana o pantalla en cualquier otro lenguaje visual.
View
Las vistas (view) son los componentes bsicos con los que se construye la interfaz grfica
de la aplicacin, anlogo por ejemplo a los controles de Java o .NET. De inicio, Android
pone a nuestra disposicin una gran cantidad de controles bsicos, como cuadros de texto,
botones, listas desplegables o imgenes, aunque tambin existe la posibilidad de extender la
funcionalidad de estos controles bsicos o crear nuestros propios controles personalizados.
21
Service
Los servicios (service) son componentes sin interfaz grfica que se ejecutan en segundo
plano. En concepto, son similares a los servicios presentes en cualquier otro sistema
operativo. Los servicios pueden realizar cualquier tipo de acciones, por ejemplo actualizar
datos, lanzar notificaciones, o incluso mostrar elementos visuales (p.ej. actividades) si se
necesita en algn momento la interaccin con del usuario.
Content Provider
Un proveedor de contenidos (content provider) es el mecanismo que se ha definido en
Android para compartir datos entre aplicaciones. Mediante estos componentes es posible
compartir determinados datos de nuestra aplicacin sin mostrar detalles sobre su
almacenamiento interno, su estructura, o su implementacin. De la misma forma, nuestra
aplicacin podr acceder a los datos de otra a travs de loscontent provider que se hayan
definido.
Broadcast Receiver
Un broadcast receiver es un componente destinado a detectar y reaccionar ante
determinados mensajes o eventos globales generados por el sistema (por ejemplo: Batera
baja, SMS recibido, Tarjeta SD insertada, ) o por otras aplicaciones (cualquier
aplicacin puede generar mensajes (intents, en terminologa Android) broadcast, es decir,
no dirigidos a una aplicacin concreta sino a cualquiera que quiera escucharlo).
Widget
Los widgets son elementos visuales, normalmente interactivos, que pueden mostrarse en la
pantalla principal (home screen) del dispositivo Android y recibir actualizaciones
peridicas. Permiten mostrar informacin de la aplicacin al usuario directamente sobre la
pantalla principal.
Intent
Un intent es el elemento bsico de comunicacin entre los distintos componentes Android
que hemos descrito anteriormente. Se pueden entender como los mensajes o peticiones que
son enviados entre los distintos componentes de una aplicacin o entre distintas
aplicaciones. Mediante un intent se puede mostrar una actividad desde cualquier otra,
iniciar un servicio, enviar un mensaje broadcast, iniciar otra aplicacin, etc.
En el siguiente artculo empezaremos ya a ver algo de cdigo, analizando al detalle una
aplicacin sencilla.
22
Desarrollando una aplicacin Android sencilla (Android Studio)
by Sgoliver on 16/01/2015 in Android, Programacin
El ritmo de actualizaciones de Android Studio es bastante alto, por lo que algunos detalles
de este artculo pueden no ajustarse exactamente a la ltima versin de la aplicacin. Este
artculo se encuentra actualizado para la versin de Android Studio 1.0.2
Despus de instalar nuestro entorno de desarrollo para Android y comentar la estructura
bsica de un proyecto y los diferentes componentes software que podemos utilizar ya es
hora de empezar a escribir algo de cdigo. Y como siempre lo mejor es empezar por
escribir una aplicacin sencilla.
En un principio me plante analizar en este captulo el clsico Hola Mundo pero ms tarde
me pareci que se iban a quedar algunas cosas bsicas en el tintero. As que he versionado a
mi manera el Hola Mundo transformndolo en algo as como un Hola Usuario, que es igual
de sencilla pero aade un par de cosas interesantes de contar. La aplicacin constar de dos
pantallas, por un lado la pantalla principal que solicitar un nombre al usuario y una
segunda pantalla en la que se mostrar un mensaje personalizado para el usuario. As de
sencillo e intil, pero aprenderemos muchos conceptos bsicos, que para empezar no est
mal.
Por dibujarlo para entender mejor lo que queremos conseguir, sera algo tan sencillo como
lo siguiente:
Vamos a partir del proyecto de ejemplo que creamos en un apartado anterior, al que
casualmente llamamos HolaUsuario.
Como ya vimos Android Studio haba creado por nosotros la estructura de carpetas del
proyecto y todos los ficheros necesarios de un Hola Mundo bsico, es decir, una sola
pantalla donde se muestra nicamente un mensaje fijo.
Lo primero que vamos a hacer es disear nuestra pantalla principal modificando la que
Android Studio nos ha creado por defecto. Aunque ya lo hemos comentado de pasada,
recordemos dnde y cmo se define cada pantalla de la aplicacin. En Android, el diseo y
la lgica de una pantalla estn separados en dos ficheros distintos. Por un lado, en el fichero
/src/main/res/layout/activity_main.xml tendremos el diseo puramente visual de la pantalla
definido como fichero XML y por otro lado, en el fichero
23
/src/main/java/paquete.java/MainActivity.java, encontraremos el cdigo java que
determina la lgica de la pantalla.
Vamos a modificar en primer lugar el aspecto de la ventana principal de la aplicacin
aadiendo los controles (views) que vemos en el esquema mostrado al principio del
apartado. Para ello, vamos a sustituir el contenido del fichero activity_main.xml por el
siguiente:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
Al pegar este cdigo en el fichero de layout aparecern algunos errores marcados en rojo,
en los valores de los atributos android:text. Es normal, lo arreglaremos pronto.
En este XML se definen los elementos visuales que componen la interfaz de nuestra
pantalla principal y se especifican todas sus propiedades. No nos detendremos mucho por
ahora en cada detalle, pero expliquemos un poco lo que vemos en el fichero.
Lo primero que nos encontramos es un elemento LinearLayout. Los layout son elementos
no visibles que determinan cmo se van a distribuir en el espacio los controles que
incluyamos en su interior. Los programadores java, y ms concretamente de Swing,
conocern este concepto perfectamente. En este caso, un LinearLayout distribuir los
controles simplemente uno tras otro y en la orientacin que indique su
propiedad android:orientation, que en este caso ser vertical.
24
Dentro del layout hemos incluido 3 controles: una etiqueta (TextView), un cuadro de texto
(EditText), y un botn (Button). En todos ellos hemos establecido las siguientes
propiedades:
android:id. ID del control, con el que podremos identificarlo ms tarde en nuestro cdigo.
Vemos que el identificador lo escribimos precedido de @+id/. Esto tendr como efecto que al compilarse el proyecto se genere automticamente una nueva constante en la
clase R para dicho control. As, por ejemplo, como al cuadro de texto le hemos asignado el
ID TxtNombre, podremos ms tarde acceder al l desde nuestro cdigo haciendo referencia
a la constante R.id.TxtNombre.
android:layout_height y android:layout_width. Dimensiones del control con respecto al
layout que lo contiene (height=alto, width=ancho). Esta propiedad tomar normalmente los
valores wrap_content para indicar que las dimensiones del control se ajustarn al contenido del mismo, o bien match_parent para indicar que el ancho o el alto del control se ajustar al alto o ancho del layout contenedor respectivamente.
Adems de estas propiedades comunes a casi todos los controles que utilizaremos, en el
cuadro de texto hemos establecido tambin la propiedad android:inputType, que indica qu
tipo de contenido va a albergar el control, en este caso ser texto normal (valor text),
aunque podra haber sido una contrasea (valor textPassword), un telfono (phone),
una fecha (date), .
Por ltimo, en la etiqueta y el botn hemos establecido la propiedad android:text, que
indica el texto que aparece en el control. Y aqu nos vamos a detener un poco, ya que
tenemos dos alternativas a la hora de hacer esto. En Android, el texto de un control se
puede especificar directamente como valor de la propiedad android:text, o bien utilizar
alguna de las cadenas de texto definidas en los recursos del proyecto (como ya vimos, en el
fichero strings.xml), en cuyo caso indicaremos como valor de la propiedad android:text su
identificador precedido del prefijo @string/. Dicho de otra forma, la primera alternativa
habra sido indicar directamente el texto como valor de la propiedad, por ejemplo en la
etiqueta de esta forma:
1
2
3
4
5
Y la segunda alternativa, la utilizada en el ejemplo, consistira en definir primero una nueva
cadena de texto en el fichero de recursos /src/main/res/values/strings.xml, por ejemplo con
identificador nombre y valor Escribe tu nombre:. 1
2
3
4
5
...
Escribe tu nombre:
...
25
Y posteriormente indicar el identificador de la cadena como valor de la
propiedad android:text, siempre precedido del prefijo @string/, de la siguiente forma: 1
2
3
4
5
Esta segunda alternativa nos permite tener perfectamente localizadas y agrupadas todas las
cadenas de texto utilizadas en la aplicacin, lo que nos podra facilitar por ejemplo la
traduccin de la aplicacin a otro idioma. Haremos esto para las dos cadenas de texto
utilizadas en el layout, nombre y aceptar. Una vez incluidas ambas cadenas de texto en
el fichero strings.xml deberan desaparecer los dos errores marcados en rojo que nos
aparecieron antes en la ventana activity_main.xml.
Con esto ya tenemos definida la presentacin visual de nuestra ventana principal de la
aplicacin, veamos ahora la lgica de la misma. Como ya hemos comentado, la lgica de la
aplicacin se definir en ficheros java independientes. Para la pantalla principal ya tenemos
creado un fichero por defecto llamado MainActivity.java. Empecemos por comentar su
cdigo por defecto:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
package net.sgoliver.android.holausuario;
import android.support.v7.app.ActionBarActivity;
import android.os.Bundle;
import android.view.Menu;
import android.view.MenuItem;
public class MainActivity extends ActionBarActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
}
@Override
public boolean onCreateOptionsMenu(Menu menu) {
// Inflate the menu; this adds items to the action bar if it is present.
getMenuInflater().inflate(R.menu.menu_main, menu);
return true;
}
@Override
public boolean onOptionsItemSelected(MenuItem item) {
// Handle action bar item clicks here. The action bar will
26
26
27
28
29
30
31
32
33
34
35
36
37
// automatically handle clicks on the Home/Up button, so long
// as you specify a parent activity in AndroidManifest.xml.
int id = item.getItemId();
//noinspection SimplifiableIfStatement
if (id == R.id.action_settings) {
return true;
}
return super.onOptionsItemSelected(item);
}
}
Como ya vimos en un apartado anterior, las diferentes pantallas de una aplicacin Android
se definen mediante objetos de tipo Activity. Por tanto, lo primero que encontramos en
nuestro fichero java es la definicin de una nueva clase MainActivity que extiende en este
caso de un tipo especial de Activityllamado ActionBarActivity, que soporta la utilizacin
de la Action Bar en nuestras aplicaciones (la action bar es la barra de ttulo y men superior
que se utiliza en la mayora de aplicaciones Android). El nico mtodo que modificaremos
por ahora de esta clase ser el mtodo onCreate(), llamado cuando se crea por primera vez
la actividad. En este mtodo lo nico que encontramos en principio, adems de la llamada a
su implementacin en la clase padre, es la llamada al
mtodo setContentView(R.layout.activity_main). Con esta llamada estaremos indicando a
Android que debe establecer como interfaz grfica de esta actividad la definida en el
recurso R.layout.activity_main, que no es ms que la que hemos especificado en el
fichero/src/main/res/layout/activity_main.xml. Una vez ms vemos la utilidad de las
diferentes constantes de recursos creadas automticamente en la clase R al compilar el
proyecto.
Adems del mtodo onCreate(), vemos que tambin se sobrescriben los
mtodos onCreateOptionsMenu() y onOptionsItemSelected(), que se utilizan para definir y
gestionar los mens de la aplicacin y/o las opciones de la action bar. Por el momento no
tocaremos estos mtodos, ms adelante en el curso nos ocuparemos de estos temas.
Antes de modificar el cdigo de nuestra actividad principal, vamos a crear una nueva
actividad para la segunda pantalla de la aplicacin anloga a sta primera, a la que
llamaremos SaludoActivity.
Para ello, pulsaremos el botn derecho sobre la carpeta /src/main/java/tu.paquete.java/ y
seleccionaremos la opcin de men New / Activity / Blank Activity.
27
En el cuadro de dilogo que aparece indicaremos el nombre de la actividad, en nuestro caso
SaludoActivity, el nombre de su layout XML asociado (Android Studio crear al mismo
tiempo tanto el layout XML como la clase java), que llamaremos activity_saludo, el ttulo
de la actividad que aparecer en la action bar. El resto de opciones las podemos dejar por
ahora con sus valores por defecto.
Pulsaremos Finish y Android Studio crear los nuevos ficheros SaludoActivity.java y
activity_saludo.xml en sus carpetas correspondientes.
De igual forma que hicimos con la actividad principal, definiremos en primer lugar la
interfaz de la segunda pantalla, abriendo el fichero activity_saludo.xml, y aadiendo esta
vez tan slo un LinearLayout como contenedor y una etiqueta (TextView) para mostrar el
mensaje personalizado al usuario.
Para esta segunda pantalla el cdigo que incluiramos sera el siguiente:
1
2
3
4
5
6
28
7
8
9
10
11
12
Por su parte, si revisamos ahora el cdigo de la clase java SaludoActivity veremos que es
anlogo a la actividad principal:
1
2
3
4
5
6
7
8
9
10
public class SaludoActivity extends ActionBarActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_saludo);
}
//...
}
Sigamos. Por ahora, el cdigo incluido en estas clases lo nico que hace es generar la
interfaz de la actividad. A partir de aqu nosotros tendremos que incluir el resto de la lgica
de la aplicacin.
Y vamos a empezar con la actividad principal MainActivity, obteniendo una referencia a
los diferentes controles de la interfaz que necesitemos manipular, en nuestro caso slo el
cuadro de texto y el botn. Para ello definiremos ambas referencias como atributos de la
clase y para obtenerlas utilizaremos el mtodo findViewById() indicando el ID de cada
control, definidos como siempre en la clase R. Todo esto lo haremos dentro del
mtodo onCreate() de la clase MainActivity, justo a continuacin de la llamada
a setContentView() que ya comentamos.
1
2
3
4
5
6
7
8
9
10
11
package net.sgoliver.android.holausuario;
//..
import android.widget.Button;
import android.widget.EditText;
public class MainActivity extends ActionBarActivity {
private EditText txtNombre;
private Button btnAceptar;
29
12
13
14
15
16
17
18
19
20
21
22
23
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
//Obtenemos una referencia a los controles de la interfaz
txtNombre = (EditText)findViewById(R.id.TxtNombre);
btnAceptar = (Button)findViewById(R.id.BtnAceptar);
}
//...
}
Como vemos, hemos aadido tambin varios import adicionales (los de las
clases Button y EditText) para tener acceso a todas las clases utilizadas.
Una vez tenemos acceso a los diferentes controles, ya slo nos queda implementar las
acciones a tomar cuando pulsemos el botn de la pantalla. Para ello, continuando el cdigo
anterior, y siempre dentro del mtodo onCreate(), implementaremos el evento onClick de
dicho botn. Este botn tendr que ocuparse de abrir la actividad SaludoActivity pasndole
toda la informacin necesaria. Veamos cmo:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
package net.sgoliver.android.holausuario;
//...
import android.content.Intent;
public class MainActivity extends ActionBarActivity {
private EditText txtNombre;
private Button btnAceptar;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
//Obtenemos una referencia a los controles de la interfaz
txtNombre = (EditText)findViewById(R.id.TxtNombre);
btnAceptar = (Button)findViewById(R.id.BtnAceptar);
//Implementamos el evento click del botn
btnAceptar.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
30
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
//Creamos el Intent
Intent intent =
new Intent(MainActivity.this, SaludoActivity.class);
//Creamos la informacin a pasar entre actividades
Bundle b = new Bundle();
b.putString("NOMBRE", txtNombre.getText().toString());
//Aadimos la informacin al intent
intent.putExtras(b);
//Iniciamos la nueva actividad
startActivity(intent);
}
});
}
}
Como ya indicamos en el apartado anterior, la comunicacin entre los distintos
componentes y aplicaciones en Android se realiza mediante intents, por lo que el primer
paso ser crear un objeto de este tipo. Existen varias variantes del constructor de la
clase Intent, cada una de ellas dirigida a unas determinadas acciones. En nuestro caso
particular vamos a utilizar el intent para iniciar una actividad desde otra actividad de la
misma aplicacin, para lo que pasaremos a su constructor una referencia a la propia
actividad llamadora (MainActivity.this), y la clase de la
actividad llamada (SaludoActivity.class).
Si quisiramos tan slo mostrar una nueva actividad ya tan slo nos quedara llamar
a startActivity() pasndole como parmetro el intent creado. Pero en nuestro ejemplo
queremos tambin pasarle cierta informacin a la actividad llamada, concretamente el
nombre que introduzca el usuario en el cuadro de texto de la pantalla principal. Para hacer
esto vamos a crear un objeto Bundle, que puede contener una lista de pares clave-valor con
toda la informacin a pasar entre actividades. En nuestro caso slo aadiremos un dato de
tipo String mediante el mtodo putString(clave, valor). Como clave para nuestro dato yo he
elegido el literal NOMBRE aunque podis utilizar cualquier otro literal descriptivo. Por
su parte, el valor de esta clave lo obtendremos consultando el contenido del cuadro de texto
de la actividad principal, lo que podemos conseguir llamando a su mtodo getText() y
convirtiendo este contenido a texto mediante toString() (ms adelante en el curso veremos
por qu es necesaria esta conversin).
Tras esto aadiremos la informacin al intent mediante el mtodo putExtras(). Si
necesitramos pasar ms datos entre una actividad y otra no tendramos ms que repetir
estos pasos para todos los parmetros necesarios.
31
Con esto hemos finalizado ya actividad principal de la aplicacin, por lo que pasaremos ya
a la secundaria. Comenzaremos de forma anloga a la anterior, ampliando el
mtodo onCreate() obteniendo las referencias a los objetos que manipularemos, esta vez
slo la etiqueta de texto. Tras esto viene lo ms interesante, debemos recuperar la
informacin pasada desde la actividad principal y asignarla como texto de la etiqueta. Para
ello accederemos en primer lugar al intent que ha originado la actividad actual mediante el
mtodo getIntent() y recuperaremos su informacin asociada (objeto Bundle) mediante el
mtodo getExtras().
Hecho esto tan slo nos queda construir el texto de la etiqueta mediante su
mtodo setText(texto) y recuperando el valor de nuestra clave almacenada en el
objeto Bundle mediante getString(clave).
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
package net.sgoliver.android.holausuario;
//...
import android.widget.TextView;
public class SaludoActivity extends ActionBarActivity {
private TextView txtSaludo;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_saludo);
//Localizar los controles
txtSaludo = (TextView)findViewById(R.id.TxtSaludo);
//Recuperamos la informacin pasada en el intent
Bundle bundle = this.getIntent().getExtras();
//Construimos el mensaje a mostrar
txtSaludo.setText("Hola " + bundle.getString("NOMBRE"));
}
//...
}
Con esto hemos concluido la lgica de las dos pantallas de nuestra aplicacin y tan slo nos
queda un paso importante para finalizar nuestro desarrollo. Como ya indicamos en un
apartado anterior, toda aplicacin Android utiliza un fichero especial en formato XML
(AndroidManifest.xml) para definir, entre otras cosas, los diferentes elementos que la
32
componen. Por tanto, todas las actividades de nuestra aplicacin deben quedar
convenientemente definidas en este fichero. En este caso, Android Studio se debe haber
ocupado por nosotros de definir ambas actividades en el fichero, pero lo revisaremos para
as echar un vistazo al contenido.
Si abrimos el fichero AndroidManifest.xml veremos que contiene un elemento
principal que debe incluir varios elementos , uno por cada
actividad incluida en nuestra aplicacin. En este caso, comprobamos como efectivamente
Android Studio ya se ha ocupado de esto por nosotros, aunque este fichero s podramos
modificarlo a mano para hacer ajustes si fuera necesario.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
Podemos ver como para cada actividad se indica entre otras cosas el nombre de su clase
java asociada como valor del atributo android:name, y su ttulo mediante el
atributo android:label, ms adelante veremos qu opciones adicionales podemos
especificar. Vemos una vez ms cmo el ttulo de las actividades se indica como referencia
a cadenas de caracteres definidas como recursos, que deben estar incluidas como ya hemos
comentado anteriormente en el fichero /main/res/values/strings.xml
El ltimo elemento que revisaremos de nuestro proyecto, aunque tampoco tendremos que
modificarlo por ahora, ser el fichero build.gradle. Pueden existir varios ficheros llamados
as en nuestra estructura de carpetas, a distintos niveles, pero normalmente siempre
33
accederemos al que est al nivel ms interno, en nuestro caso el que est dentro del mdulo
app. Veamos qu contiene:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
apply plugin: 'com.android.application'
android {
compileSdkVersion 21
buildToolsVersion "21.1.2"
defaultConfig {
applicationId "net.sgoliver.android.holausuario"
minSdkVersion 15
targetSdkVersion 21
versionCode 1
versionName "1.0"
}
buildTypes {
release {
minifyEnabled false
proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
}
}
}
dependencies {
compile fileTree(dir: 'libs', include: ['*.jar'])
compile 'com.android.support:appcompat-v7:21.0.3'
}
Gradle es el nuevo sistema de compilacin y construccin que ha adoptado Google para
Android Studio. Pero no es un sistema especfico de Android, sino que puede utilizarse
con otros lenguajes/plataformas. Por tanto, lo primero que indicamos en este fichero es que
utilizaremos el plugin para Android mediante la sentencia apply plugin. A continuacin
definiremos varias opciones especficas de Android, como las versiones de la API mnima
(minSdkVersion), API objetivo (targetSdkVersion), y API de compilacin
(compileSdkVersion) que utilizaremosen el proyecto, la versin de las build
tools (buildToolsVersion) que queremos utilizar (es uno de los componentes que podemos
descargar/actualizar desde el SDK Manager), la versin tanto interna (versionCode) como
visible (versionName) de la aplicacin, o la configuracin de ProGuard si estamos haciendo
uso de l (no nos preocupamos por ahora de esto). Durante el curso iremos viendo con ms
detalle todos estos elementos. El ultimo elemento llamado dependencies tambin es
importante y nos servir entre otras cosas para definir las libreras externas que utilizaremos
34
en la aplicacin. Por defecto vemos que se aade la librera de
compatibilidad appcompatque nos permite utilizar la Action Bar en la mayora de versiones
de Android, y todos los fichero .jar que incluyamos en la carpeta /libs.
Llegados aqu, y si todo ha ido bien, deberamos poder ejecutar el proyecto sin errores y
probar nuestra aplicacin en el emulador, pero para ello tendremos que definir primero uno.
Vamos a describir los pasos para hacerlo.
Para poder probar aplicaciones Android en nuestro PC, sin tener que recurrir a un
dispositivo fsico, tenemos que definir lo que se denominan AVD (Android Virtual Device).
Para crear un AVD seleccionaremos el men Tools / Android / AVD Manager. Si es la
primera vez que accedemos a esta herramienta veremos la pantalla siguiente:
Pulsando el botn central Create a virtual device accederemos al asistente para crear un
AVD. En el primer paso tendremos que seleccionar a la izquierda qu tipo de dispositivo
queremos que simule nuestro AVD (telfono, tablet, reloj, ) y el tamao, resolucin, y
densidad de pxeles de su pantalla. En mi caso seleccionar por ejemplo las caractersticas
de un Nexus 4 y pasaremos al siguiente paso pulsando Next.
En la siguiente pantalla seleccionaremos la versin de Android que utilizar el AVD.
Aparecern directamente disponibles las que instalamos desde el SDK Manager al instalar
el entorno, aunque tenemos la posibilidad de descargar e instalar nuevas versiones desde
esta misma pantalla. En mi caso utilizar KitKat (API 19) para este primer AVD (podemos
crear tantos como queramos para probar nuestras aplicaciones sobre distintas condiciones).
35
En el siguiente paso del asistente podremos configurar algunas caractersticas ms del
AVD, como por ejemplo la cantidad de memoria que tendr disponible, si simular tener
cmara frontal y/o trasera, teclado fsico, Recomiendo pulsar el botn Show Advanced
Settings para ver todas las opciones disponibles. Si quieres puedes ajustar cualquiera de
estos parmetros, pero por el momento os recomiendo dejar todas las opciones por defecto.
Tan slo nos aseguraremos de tener activada la opcin Use Host GPU con la que
normalmente conseguiremos un mayor rendimiento del emulador.
Tras pulsar el botn Finish tendremos ya configurado nuestro AVD, por lo que podremos
comenzar a probar nuestras aplicaciones sobre l.
Para ello pulsaremos simplemente el men Run / Run app (o la tecla rpida Mays+F10).
Android Studio nos preguntar en qu dispositivo queremos ejecutar la aplicacin y nos
mostrar dos listas. La primera de ellas con los dispositivos que haya en ese momento en
funcionamiento (por ejemplo si ya tenamos un emulador funcionando) y una lista
36
desplegable con el resto de AVDs configurados en nuestro entorno. Podremos seleccionar
cualquiera de los emuladores disponibles en cualquiera de las dos listas. Lo normal ser
mantener un emulador siempre abierto y seleccionarlo de la primera lista cada vez que
ejecutemos la aplicacin.
Elegir para este ejemplo el AVD que acabamos de crear y configurar. Es posible que la
primera ejecucin se demore unos minutos, todo depender de las caractersticas de vuestro
PC, as que paciencia.
Si todo va bien, tras una pequea (o no tan pequea) espera aparecer el emulador de
Android y se iniciar automticamente nuestra aplicacin (si se inicia el emulador pero no
se ejecuta automticamente la aplicacin podemos volver a ejecutarla desde Android
Studio, mediante el men Run, sin cerrar el emulador ya abierto).
Podemos probar a escribir un nombre y pulsar el botn Aceptar para comprobar si el
funcionamiento es el correcto.
37
Y con esto terminamos por ahora. Espero que esta aplicacin de ejemplo os sea de ayuda
para aprender temas bsicos en el desarrollo para Android, como por ejemplo la definicin
de la interfaz grfica, el cdigo java necesario para acceder y manipular los elementos de
dicha interfaz, y la forma de comunicar diferentes actividades de Android. En los apartados
siguientes veremos algunos de estos temas de forma mucho ms especfica.
Podis consultar online y descargar el cdigo fuente completo de este artculo desde github.
Interfaz de Usuario en Android
Interfaz de usuario en Android: Layouts
by Sgoliver on 17/08/2010 in Android, Programacin
En el artculo anterior del curso, donde desarrollamos una sencilla aplicacin Android
desde cero, ya hicimos algunos comentarios sobre los layouts. Como ya indicamos,
los layouts son elementos no visuales destinados a controlar la distribucin, posicin y
dimensiones de los controles que se insertan en su interior. Estos componentes extienden a
la clase base ViewGroup, como muchos otros componentes contenedores, es decir, capaces
de contener a otros controles. En el post anterior conocimos la existencia de un tipo
concreto de layout, LinearLayout, aunque Android nos proporciona algunos otros. Vemos
cuntos y cules.
38
FrameLayout
ste es el ms simple de todos los layouts de Android. Un FrameLayout coloca todos sus
controles hijos alineados con su esquina superior izquierda, de forma que cada control
quedar oculto por el control siguiente (a menos que ste ltimo tenga transparencia). Por
ello, suele utilizarse para mostrar un nico control en su interior, a modo de contenedor
(placeholder) sencillo para un slo elemento sustituible, por ejemplo una imagen.
Los componentes incluidos en un FrameLayout podrn establecer sus propiedades
android:layout_width y android:layout_height, que podrn tomar los valores
match_parent (para que el control hijo tome la dimensin de su layout contenedor) o
wrap_content (para que el control hijo tome la dimensin de su contenido). Veamos un
ejemplo:
Ejemplo:
1
2
3
4
5
6
7
8
9
10
11
Con el cdigo anterior conseguimos un layout tan sencillo como el siguiente:
LinearLayout
El siguiente tipo de layout en cuanto a nivel de complejidad es el LinearLayout. Este layout
apila uno tras otro todos sus elementos hijos en sentido horizontal o vertical segn se
establezca su propiedad android:orientation.
39
Al igual que en un FrameLayout, los elementos contenidos en un LinearLayout pueden
establecer sus propiedades android:layout_width y android:layout_height para determinar
sus dimensiones dentro del layout.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
Pero en el caso de un LinearLayout, tendremos otro parmetro con el que jugar, la
propiedadandroid:layout_weight. Esta propiedad nos va a permitir dar a los elementos
contenidos en el layout unas dimensiones proporcionales entre ellas. Esto es ms dificil de
explicar que de comprender con un ejemplo. Si incluimos en un LinearLayout vertical dos
cuadros de texto (EditText) y a uno de ellos le establecemos un layout_weight=1 y al otro
un layout_weight=2 conseguiremos como efecto que toda la superficie del layout quede
ocupada por los dos cuadros de texto y que adems el segundo sea el doble (relacin entre
sus propiedades weight) de alto que el primero.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
40
18
19
Con el cdigo anterior conseguiramos un layout como el siguiente:
As pues, a pesar de la simplicidad aparente de este layout resulta ser lo suficiente verstil
como para sernos de utilidad en muchas ocasiones.
TableLayout
Un TableLayout permite distribuir sus elementos hijos de forma tabular, definiendo las filas
y columnas necesarias, y la posicin de cada componente dentro de la tabla.
La estructura de la tabla se define de forma similar a como se hace en HTML, es decir,
indicando las filas que compondrn la tabla (objetos TableRow), y dentro de cada fila las
columnas necesarias, con la salvedad de que no existe ningn objeto especial para definir
una columna (algo as como unTableColumn) sino que directamente insertaremos los
controles necesarios dentro del TableRow y cada componente insertado (que puede ser un
control sencillo o incluso otro ViewGroup) corresponder a una columna de la tabla. De
esta forma, el nmero final de filas de la tabla se corresponder con el nmero de
elementos TableRow insertados, y el nmero total de columnas quedar determinado por el
nmero de componentes de la fila que ms componentes contenga.
Por norma general, el ancho de cada columna se corresponder con el ancho del mayor
componente de dicha columna, pero existen una serie de propiedades que nos ayudarn a
modificar este comportamiento:
android:stretchColumns. Indicar las columnas que pueden expandir para absorver el
espacio libre dejado por las dems columnas a la derecha de la pantalla.
android:shrinkColumns. Indicar las columnas que se pueden contraer para dejar espacio al
resto de columnas que se puedan salir por la derecha de la palntalla.
android:collapseColumns. Indicar las columnas de la tabla que se quieren ocultar
completamente.
41
Todas estas propiedades del TableLayout pueden recibir una lista de ndices de columnas
separados por comas (ejemplo: android:stretchColumns=1,2,3) o un asterisco para indicar
que debe aplicar a todas las columnas (ejemplo: android:stretchColumns=*).
Otra caracterstica importante es la posibilidad de que una celda determinada pueda ocupar
el espacio de varias columnas de la tabla (anlogo al atributo colspan de HTML). Esto se
indicar mediante la propiedad android:layout_span del componente concreto que deber
tomar dicho espacio.
Veamos un ejemplo con varios de estos elementos:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
El layout resultante del cdigo anterior sera el siguiente:
42
GridLayout
Este tipo de layout fue incluido a partir de la API 14 (Android 4.0) y sus caractersticas son
similares alTableLayout, ya que se utiliza igualmente para distribuir los diferentes
elementos de la interfaz de forma tabular, distribuidos en filas y columnas. La diferencia
entre ellos estriba en la forma que tiene elGridLayout de colocar y distribuir sus elementos
hijos en el espacio disponible. En este caso, a diferencia del TableLayout indicaremos el
nmero de filas y columnas como propiedades del layout,
medianteandroid:rowCount y android:columnCount. Con estos datos ya no es necesario
ningn tipo de elemento para indicar las filas, como hacamos con el
elemento TableRow del TableLayout, sino que los diferentes elementos hijos se irn
colocando ordenadamente por filas o columnas (dependiendo de la
propiedad android:orientation) hasta completar el nmero de filas o columnas indicadas en
los atributos anteriores. Adicionalmente, igual que en el caso anterior, tambin tendremos
disponibles las propiedades android:layout_rowSpan y android:layout_columnSpan para
conseguir que una celda ocupe el lugar de varias filas o columnas.
Existe tambin una forma de indicar de forma explcita la fila y columna que debe ocupar
un determinado elemento hijo contenido en el GridLayout, y se consigue utilizando los
atributos android:layout_row yandroid:layout_column. De cualquier forma, salvo para
configuraciones complejas del grid no suele ser necesario utilizar estas propiedades.
Con todo esto en cuenta, para conseguir una distribucin equivalente a la del ejemplo
anterior delTableLayout, necesitaramos escribir un cdigo como el siguiente:
1
2
3
4
5
6
7
43
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
RelativeLayout
El ltimo tipo de layout que vamos a ver es el RelativeLayout. Este layout permite
especificar la posicin de cada elemento de forma relativa a su elemento padre o a
cualquier otro elemento incluido en el propio layout. De esta forma, al incluir un nuevo
elemento X podremos indicar por ejemplo que debe colocarsedebajo del elemento
Y y alineado a la derecha del layout padre. Veamos esto en el ejemplo siguiente:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
En el ejemplo, el botn BtnAceptar se colocar debajo del cuadro de
texto TxtNombre(android:layout_below=@id/TxtNombre) y alineado a la derecha del
layout padre (android:layout_alignParentRight=true), Quedara algo as:
44
Al igual que estas tres propiedades, en un RelativeLayout tendremos un sinfn de
propiedades para colocar cada control justo donde queramos. Veamos las principales [creo
que sus propios nombres explican perfectamente la funcin de cada una]:
Posicin relativa a otro control: android:layout_above
android:layout_below
android:layout_toLeftOf
android:layout_toRightOf
android:layout_alignLeft
android:layout_alignRight
android:layout_alignTop
android:layout_alignBottom
android:layout_alignBaseline
Posicin relativa al layout padre: android:layout_alignParentLeft
android:layout_alignParentRight
android:layout_alignParentTop
android:layout_alignParentBottom
android:layout_centerHorizontal
android:layout_centerVertical
android:layout_centerInParent
Por ltimo indicar que cualquiera de los tipos de layout anteriores poseen otras propiedades
comunes como por ejemplo los mrgenes exteriores (margin) e interiores (padding) que
pueden establecerse mediante los siguientes atributos:
Opciones de margen exterior: android:layout_margin
android:layout_marginBottom
android:layout_marginTop
45
android:layout_marginLeft
android:layout_marginRight
Opciones de margen interior:
android:padding
android:paddingBottom
android:paddingTop
android:paddingLeft
android:paddingRight
Existen otros layouts algo ms sofisticados a los que dedicaremos artculos especficos un
poco ms adelante, como por ejemplo el DrawerLayout para aadir mens laterales
deslizantes.
Tambin en prximos artculos veremos otros elementos comunes que extienden
a ViewGroup, como por ejemplo las vistas de tipo lista (ListView), de tipo grid
(GridView), y las pestaas o tabs (TabHost/TabWidget).
Interfaz de usuario en Android: Controles bsicos (I)
by Sgoliver on 19/08/2010 in Android, Programacin
En el captulo anterior del curso vimos los distintos tipos de layouts con los que contamos
en Android para distribuir los controles de la interfaz por la pantalla del dispositivo. En los
prximos captulos vamos a hacer un repaso de los diferentes controles que pone a nuestra
disposicin la plataforma de desarrollo de este sistema operativo. Empezaremos con los
controles ms bsicos y seguiremos posteriormente con algunos algo ms elaborados.
En este primer post sobre el tema nos vamos a centrar en los diferentes tipos de botones y
cmo podemos personalizarlos. El SDK de Android nos proporciona tres tipos de botones:
los clsicos de texto (Button), los que pueden contener una imagen (ImageButton), y los de
tipo on/off (ToggleButton y Switch).
No vamos a comentar mucho sobre ellos dado que son controles de sobra conocidos por
todos, ni vamos a enumerar todas sus propiedades porque existen decenas. A modo de
referencia, a medida que los vayamos comentando ir poniendo enlaces a su pgina de la
documentacin oficial de Android para poder consultar todas sus propiedades en caso de
necesidad.
Control Button [API]
46
Un control de tipo Button es el botn ms bsico que podemos utilizar y normalmente
contiene un simple texto. En el ejemplo siguiente definimos un botn con el texto Click
asignando su propiedadandroid:text. Adems de esta propiedad podramos utilizar muchas
otras como el color de fondo (android:background), estilo de fuente (android:typeface),
color de fuente (android:textcolor), tamao de fuente (android:textSize), etc.
1
2
3
4
Este botn quedara como se muestra en la siguiente imagen:
Control ToggleButton [API]
Un control de tipo ToggleButton es un tipo de botn que puede permanecer en dos posibles
estados, pulsado o no_pulsado. En este caso, en vez de definir un slo texto para el control
definiremos dos, dependiendo de su estado. As, podremos asignar las
propiedades android:textOn y android:textoOff para definir ambos textos. Veamos un
ejemplo a continuacin.
1
2
3
4
5
El botn se mostrara de alguna de las dos formas siguientes, dependiendo de su estado:
Control Switch [API]
Un control Switch es muy similar al ToggleButton anterior, donde tan slo cambia su
aspecto visual, que en vez de mostrar un estado u otro sobre el mismo espacio, se muestra
en forma de deslizador o interruptor. Su uso sera completamente anlogo al ya comentado:
1
47
2
3
4
5
android:textOn="@string/on"
android:textOff="@string/off"
android:layout_width="wrap_content"
android:layout_height="wrap_content" />
Y su aspecto sera el siguiente:
Control ImageButton [API]
En un control de tipo ImageButton podremos definir una imagen a mostrar en vez de un
texto, para lo que deberemos asignar la propiedad android:src. Normalmente asignaremos
esta propiedad con el descriptor de algn recurso que hayamos incluido en las
carpetas /res/drawable. As, por ejemplo, en nuestro caso vamos a incluir una imagen
llamada ic_estrella.png por lo que haremos referencia al recurso
@drawable/ic_estrella. Adicionalmente, al tratarse de un control de tipo imagen tambin
deberamos acostumbrarnos a asignar la propiedad android:contentDescription con una
descripcin textual de la imagen, de forma que nuestra aplicacin sea lo ms accesible
posible.
1
2
3
4
5
En una aplicacin el botn anterior se mostrara de la siguiente forma:
Aadir imgenes a un proyecto de Android Studio
Android Studio incorpora una utilidad llamada Asset Studio con la que podemos aadir
rpidamente a un proyecto algunas imgenes o iconos estandar de entre una lista bastante
amplia de muestras disponibles, o utilizar nuestras propias imgenes personalizadas.
Podemos acceder a esta utilidad haciendo por ejemplo click derecho sobre la
carpeta /main/res del proyecto y seleccionando la opcin New / Image Asset:
48
Esto nos da acceso a Asset Studio, donde podremos indicar el tipo de imagen a aadir
(icono de lanzador, icono de action bar, icono de notificacin, ), el origen de la imagen
(Image = Fichero externo, Clipart = Coleccin de iconos estandar, Text = Texto
personalizado), el tema de nuestra aplicacin (lo que afectar al color de fondo y primer
plano de los iconos seleccionados), y el nombre del recurso a incluir en el proyecto.
As, en nuestro caso de ejemplo, seleccion Clipart como origen de la imagen, seleccion
el icono de estrella mediante el botn Choose, e indiqu el nombre ic_estrella:
Al pulsar el botn Next el sistema consulta en qu mdulo del proyecto y en qu carpeta de
recursos del mdulo colocar los recursos creados para el icono. Adems, como podemos
ver en la siguiente imagen Asset Studio se encarga de crear el icono para las distintas
densidades de pixeles y colocarlo en su carpeta de recursos correspondiente.
49
Cabe decir adems, que aunque existe este tipo especfico de botn para imgenes, tambin
es posible aadir una imagen a un botn normal de tipo Button, a modo de elemento
suplementario al texto (compound drawable). Por ejemplo, si quisiramos aadir un icono a
la izquierda del texto de un botn utilizaramos la
propiedad android:drawableLeft indicando como valor el descriptor (ID) de la imagen que
queremos mostrar, y si fuera necesario podramos indicar tambin el espacio entre la
imagen y el texto mediante la propiedad android:drawablePadding:
1
2
3
4
5
6
El botn mostrado en este caso sera similar a ste:
Eventos de un botn
Como podis imaginar, aunque estos controles pueden lanzar muchos otros eventos, el ms
comn de todos ellos y el que querremos capturar en la mayora de las ocasiones es el
evento onClick, que se lanza cada vez que el usuario pulsa el botn. Para definir la lgica
de este evento tendremos que implementarla definiendo un nuevo
objeto View.OnClickListener() y asocindolo al botn mediante el mtodo
setOnClickListener(). La forma ms habitual de hacer esto es la siguiente:
50
1
2
3
4
5
6
7
8
btnBotonSimple = (Button)findViewById(R.id.BtnBotonSimple);
btnBotonSimple.setOnClickListener(new View.OnClickListener() {
public void onClick(View arg0)
{
lblMensaje.setText("Botn Simple pulsado!");
}
});
En el caso de un botn de tipo ToggleButton o Switch suele ser de utilidad conocer en qu
estado ha quedado el botn tras ser pulsado, para lo que podemos utilizar su
mtodo isChecked(). En el siguiente ejemplo se comprueba el estado del botn tras ser
pulsado y se realizan acciones distintas segn el resultado.
1
2
3
4
5
6
7
8
9
10
11
btnToggle = (ToggleButton)findViewById(R.id.BtnToggle);
btnToggle.setOnClickListener(new View.OnClickListener() {
public void onClick(View arg0)
{
if(btnToggle.isChecked())
lblMensaje.setText("Botn Toggle: ON");
else
lblMensaje.setText("Botn Toggle: OFF");
}
});
Personalizar el aspecto un botn (y otros controles)
En las imgenes mostradas durante este apartado hemos visto el aspecto que presentan por
defecto los diferentes tipos de botones disponibles. Pero, y si quisiramos personalizar su
aspecto ms all de cambiar un poco el tipo o el color de la letra o el fondo?
Para cambiar la forma de un botn podramos simplemente asignar una imagen a la
propiedadandroid:background, pero esta solucin no nos servira de mucho porque siempre
se mostrara la misma imagen incluso con el botn pulsado, dando poca sensacin de
elemento clickable.
La solucin perfecta pasara por tanto por definir diferentes imgenes de fondo
dependiendo del estado del botn. Pues bien, Android nos da total libertad para hacer esto
mediante el uso de selectores. Un selectorse define mediante un fichero XML localizado en
51
la carpeta /res/drawable, y en l se pueden establecer los diferentes valores de una
propiedad determinada de un control dependiendo de su estado.
Por ejemplo, si quisiramos dar un aspecto diferente a nuestro botn ToggleButton, para
que sea de color azul y con esquinas redondeadas, podramos disear las imgenes
necesarias para los estados pulsado (en el ejemplo toggle_on.9.png) y no pulsado (en el
ejemplo toggle_off.9.png) y crear un selector como el siguiente:
1
2
3
4
En el cdigo anterior vemos cmo se asigna a cada posible estado del botn una imagen (un
elemento drawable) determinada. As, por ejemplo, para el estado pulsado
(state_checked=true) se asigna la imagen toggle_on.
Este selector lo guardamos por ejemplo en un fichero llamado toggle_style.xml y lo
colocamos como un recurso ms en nuestra carpeta de recursos /res/drawable. Hecho esto,
tan slo bastara hacer referencia a este nuevo recurso que hemos creado en la
propiedad android:background del botn:
1
2
3
4
5
6
En la siguiente imagen vemos el aspecto por defecto de
nuestro ToggleButton personalizado con los cambios indicados:
Botones sin borde
Otra forma de personalizar los controles en Android es utilizando estilos. Los estilos
merecen un captulo a parte, pero comentaremos aqu algunos muy utilizados en las ltimas
versiones de Android, concretamente en el tema que nos ocupa de los botones.
En determinadas ocasiones, como por ejemplo cuando se utilizan botones dentro de otros
elementos como listas o tablas, es interesante contar con todas la funcionalidad de un botn
52
pero prescindiendo sus bordes de forma que adquiera un aspecto plano y se intergre mejor
con el diseo de la interfaz. Para ello, podemos utilizar el
estilo borderlessButtonStyle como estilo del botn (propiedad style), de forma que ste se
mostrar sin bordes pero conservar otros detalles como el cambio de apariencia al ser
pulsado. Veamos cmo se definira por ejemplo un ImageButton sin borde:
1
2
3
4
5
6
En la siguiente imagen vemos cmo quedara este botn integrado dentro de
un LinearLayout y alineado a la derecha:
El separador vertical que se muestra entre el texto y el botn se consigue utilizando las
propiedadesshowDividers, divider, y dividerPadding del layout contenedor (para mayor
claridad puede consultarse el cdigo completo):
1
2
3
4
5
6
7
8
Otro lugar muy habitual donde encontrar botones sin borde es en las llamadas barras de
botones (button bar) que muestran muchas aplicaciones. Para definir una barra de botones,
utilizaremos normalmente como contenedor un LinearLayout horizontal e incluiremos
dentro de ste los botones (Button) necesarios, asignando a cada elelemento su estilo
correspondiente, en este caso buttonBarStyle para el contenedor,
y buttonBarButtonStyle para los botones. En nuetro ejemplo crearemos una barra con dos
botones, Aceptar y Cancelar, que quedara as:
1
2
3
4
5
6
7
8
53
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
Visualmente el resultado sera el siguiente:
Botones flotantes (Floating Action Button / FAB)
Como contenido extra de este captulo voy a hacer mencin a un nuevo tipo de botn
aparecido a raiz de la nueva filosofa de diseo Android llamada Material Design. Me
refiero a los botones de accin flotantes que estn incorporando muchas aplicaciones, sobre
todo tras su actualizacin a Android 5 Lollipop.
El inconveniente de este tipo de botones es que no estn incluidos de forma nativa en las
API de la plataforma, por lo que tenemos que construirlos como control
personalizado (ms adelante en el curso hablaremos de esto) o bien utilizar alguna de las
muchas libreras externas que ya lo implementan. Para no complicar ms este captulo voy
a indicar simplemente cmo utilizar una de las libreras open source ms sencillas que
implementan este tipo de control, disponible como proyecto en github: android-floating-
action-button.
Aadir libreras externas a un proyecto de Android Studio
Para hacer uso de una librera externa en un proyecto de Android Studio tenemos dos
posibilidades: aadir el fichero jar de la librera a la carpeta /libs del mdulo, o bien aadir
la referencia a la librera (si est disponible) como dependencia en el
fichero build.gradle del mdulo. En este caso, en la web de la librera nos informan de los
datos necesarios para aadir la librera como dependencia (apartado Usage de la web).
54
Por tanto usaremos esta opcin aadiendo a nuestro ficherobuild.gradle la siguiente lnea
en el apartado dependencies:
dependencies {
compile com.getbase:floatingactionbutton:1.6.0
}
Una vez aadida la referencia a la librera, salvamos el fichero y nos aseguramos de pulsar
la opcin Sync Now que nos aparecer en la parte superior derecha del editor de cdigo:
Tras esto, Android Studio se encargar de descargar automticamente los ficheros
necesarios y cuando sea necesario para que podamos hacer uso de la librera.
Una vez aadida la librera al proyecto como se describe en la nota anterior, podremos
aadir un botn flotante a nuestra interfaz aadiendo un nuevo elemento a nuestro layout
principal activity_main.xml de la siguiente forma:
1
2
3
4
5
6
7
Con las propiedades fab_plusIconColor, fab_colorNormal y fab_colorPressed indicamos
los distintos colores del botn. Si en vez de un botn clsico de Aadir quisiramos
utilizar cualquier otro icono en el botn podemos utilizar FloatingActionButton en vez
de AddFloatingActionButton e indicar el icono a utilizar con la propiedad