PROGRAMACIÓN MOBILE EN ANDROID

1
ÍNDICE
................................................................................................................................................1
Módulo Conceptos Generales...............................................................................................3
1 Entorno de desarrollo Android Studio.............................................................................3
Paso 1. Descarga e instalación de Java.......................................................................3
Paso 2. Descarga e instalación de Android Studio y el SDK de Android......................5
Paso 3. Configuración inicial de Android Studio...........................................................9
Paso 4. Instalar/actualizar componentes del SDK de Android.....................................9
PARA PROFUNDIZAR................................................................................................11
2 Estructura de un proyecto Android...............................................................................12
PARA PROFUNDIZAR................................................................................................19
3 Componentes y archivos principales de una aplicación Android.................................20
Vistas...........................................................................................................................21
Adaptadores................................................................................................................22
Modelo de Datos.........................................................................................................22
Tareas o Tasks.............................................................................................................23
Actividades..................................................................................................................23
Fragmentos..................................................................................................................23
4. Desarrollando una app sencilla...................................................................................26
1 Crear el proyecto......................................................................................................26
2 Modificar la vista activity_saludo..............................................................................26
3 Modificar la actividad SaludoActivity........................................................................29
4 Crear la actividad MostrarSaludoActivity.................................................................31
5 Editar la vista activity_mostrar_saludo.....................................................................31
6 Editar la actividad SaludoActivity.............................................................................32
7 Editar la actividad MostrarSaludoActivity.................................................................33
8 Ejecutar el proyecto..................................................................................................33
9 Probar la aplicación..................................................................................................37
EJERCICIOS..............................................................................................................38

2
Módulo Conceptos Generales
Este módulo tiene como objetivo mostrar al desarrollador el proceso de instalación tanto
de Android Studio como de los complementos que se necesiten para su correcto
funcionamiento. Una vez instalado el entorno, se expondrá un pequeño ejemplo de
desarrollo de una aplicación básica en Android.

1 Entorno de desarrollo Android Studio

En este capítulo se explicará el proceso de descarga e instalación del entorno de
desarrollo Android Studio y los complementos que permiten su correcto funcionamiento.
Además, se guiará el proceso de instalación tanto para entornos con sistema operativo
Windows como para entornos con Linux.

Paso 1. Descarga e instalación de Java.

Si aún no tienes instalado ninguna versión del JDK (Java Development Kit) se puede
descargarla gratuitamente desde la web de Oracle. Aparecen distintas versiones de JDK,
siendo válidas todas las que aparezcan, se recomienda elegir la más reciente. Además,
para la versión elegida, se deberá seleccionar el JDK que corresponda con las
características del sistema operativo usado.

Ilustración 1: Descarga JDK.

3
JDK para Windows
Se trata de un instalador estándar de Windows donde tan sólo hay que aceptar, pantalla
por pantalla, todas las opciones que ofrece por defecto.
El siguiente paso es opcional, pero puede evitarnos algún que otro problema en el futuro.
Se creará 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_79“. Para
añadir una variable de entorno del sistema en Windows, se puede acceder al Panel de
Control / Sistema y Seguridad / Sistema / Configuración avanzada del sistema / Opciones
Avanzadas / Variables de entorno. Una vez en la ventana de Variables de Entorno, pulsar
el botón “Nueva…” del apartado de Variables del Sistema y añadir la nueva variable con
los valores indicados anteriormente.

JDK para linux

Se puede elegir entre dos tipos distintos de extensiones de JDK:

.tar.gz
1. Se abre la terminal y se accede al directorio donde se encuentra el archivo. (Comando
cd)
2. Se descomprime el JDK y se instala usando el siguiente comando en la terminal.
tar zxvf <nombre del archivo jdk>.tar.gz

El JDK será instalado en el directorio actual bajo el nombre jdk1.8.0_versión.

3. Se borra el archivo .tar.gz.

.rpm
1. Se abre la terminal y convertirnos en súper usuario (comando su).
2. Desinstalar, en caso de que hubiera instalaciones previas del JDK. Se introduce en la
terminal el siguiente comando.
rpm -e nombre_del_paquete_antiguo

3. Instalar el JDK. Se introduce en la terminal el siguiente comando.

rpm -ivh <nombre del archivo jdk>.rpm

4
4. Se actualiza.
rpm -Uvh <nombre del archivo jdk>.rpm

5. Se borra el archivo .rpm

Paso 2. Descarga e instalación de Android Studio y el SDK de Android.

Se accederá a la sección Android Studio de la página web oficial de Android. Se pulsará
sobre el botón verde que aparece en la siguiente ilustración y acto seguido, empezará la
descarga.

Ilustración 2: Descarga de Android Studio.

Para sistemas operativos Windows, se deberá ejecutar el instalador descargado y

seguir el asistente aceptando todas las opciones seleccionadas por defecto. Durante el
proceso se instalará el SDK de Android, algunos componentes adicionales para el
desarrollo sobre la plataforma, y el entorno de desarrollo Android Studio.

Para sistemas operativos Linux, se deberá extraer el archivo .zip descargado, abrir la
terminal y navegar mediante el comando cd hasta la carpeta android-studio/bin/ del zip
descargado. Una vez dentro, se deberá ejecutar el archivo studio.sh.
cd Programacion/Android/android-studio/bin/
./studio.sh

5
El resultante de este proceso es el mostrado en la siguiente ilustración.

Ilustración 3: Descarga JDK.

Durante la instalación se deberá indicar también las rutas donde se quiere instalar tanto
Android Studio como el SDK de Android. Para evitar posibles problemas futuros, está
recomendado seleccionar rutas que no contengan espacios en blanco.

6
Ilustración 4: Configuración de las rutas de instalación y del SDK.

En el último paso de la instalación, se marcará la opción “Start Android Studio” y se

pulsará el botón “Finish” de forma que se iniciará automáticamente la aplicación. Es
posible que aparezca un cuadro de diálogo consultando si se quiere reutilizar la
configuración de alguna versión anterior del entorno. Para realizar una instalación limpia,
seleccionaremos la opción “I do not have a previous version…“.

Ilustración 5: Diálogo para seleccionar una configuración previa.

Tras esto, se iniciará el asistente de inicio de Android Studio. Se pulsará Next y en el

siguiente paso se seleccionará el modo de instalación “Custom”:

7
Ilustración 6: Asistente de instalación de Android Studio I.

En la siguiente pantalla del asistente, se seleccionarán los componentes que se quieren

instalar. Es importante asegurarse de que en el campo “Android SDK Location” se indica
la ruta donde se ha instalado anteriormente el SDK, por último, se marcarán únicamente
los componentes “Android SDK” y “Performance (Intel HAXM)” (si aparece disponible, ya
que mejorará el rendimiento del emulador de Android).
Se revisará el resumen de opciones seleccionadas durante el asistente, y se pulsará el
botón Finish para comenzar con la descarga e instalación de los elementos necesarios.
Una vez finalizada la descarga, se pulsará el botón Finish que dará paso a la pantalla de
bienvenida de Android Studio.

Ilustración 7: Asistente de instalación de Android Studio II.

8
Paso 3. Configuración inicial de Android Studio.
El siguiente paso será asegurarse de que están correctamente configuradas las rutas a
los SDK de Java y Android. Para ello se accederá al menú “Configure” de la pantalla de
bienvenida. Se entrará en el submenú “Project Defaults” y se pulsará sobre la opción
“Project Structure”. En la ventana de opciones resultante, se revisará el apartado “SDK
Location”. Si todo está en orden, se deberá pulsar el botón “OK”.

Paso 4. Instalar/actualizar componentes del SDK de Android.

En el siguiente paso se procederá a actualizar algunos componentes del SDK de Android
e instalar otros adicionales que nos pueden ser necesarios o útiles para el desarrollo de
nuestras aplicaciones.
Para ello se accederá al menú “Settings” - “System Settings” - “Androis SDK”. Con esta
herramienta se podrá instalar, desinstalar, o actualizar todos los componentes disponibles
como parte del SDK de Android.
Aparecen tres pestañas en esta ventana: SDK Platforms, SDK Tools, SDK Updates.

SDK Platforms
Se deberá marcar al menos una opción de las listadas, recomendablemente, la que
cuente con el “API Level” más elevado. Estos SDK cuentan con las funciones que nos
permiten compilar las aplicaciones Android.

9
Ilustración 8: Pestaña SDK Plataforms de la pantalla de configuración del SDK.

SDK Tools
Es recomendable marcar para descargarse las opciones “Android SDK Biuld-Tools”,
“Android SDK Platforms-Tools” y “Android SDK Tools”. Tener actualizados estos paquetes
permitirá optar a las mejoras que vaya lanzando Google con el objetivo de facilitar ciertas
operaciones a los desarrolladores.

10
Ilustración 9: Pestaña SDK Tools de la pantalla de configuración del SDK.

Una vez seleccionadas las opciones a instalar, se pulsará en “Apply” y comenzará la

descarga e instalación.

PARA PROFUNDIZAR
Instalación Android studio linux.
Instalación Android Studio Windows.
Instalación JDK Linux
Instalación JDK Windows

11
2 Estructura de un proyecto Android
En este capítulo se hablará de cómo crear un proyecto con Android Studio, de las
consideraciones que se deben tener en cuenta y de la estructura básica y jerarquía de los
componentes que forman una aplicación.
Para crear un proyecto nuevo, si nos encontramos en la vista de otro proyecto se pulsará
en el menú “File” - “New” - “New proyect”. Si, por otro lado, al abrir el entorno, aparece la
pantalla de bienvenida, se pulsará en la opción “Start a new Android Studio Proyect”. En
ambos casos la pantalla resultante será la mostrada en la siguiente ilustración.

Ilustración 10: Pantalla de creación de un nuevo proyecto I.

Se deberá rellenar el nombre del proyecto, el dominio para la aplicación y la ubicación de

éste. Una vez introducida la información, avanzaremos a la siguiente pantalla pulsando
en el botón “Next”.

12
Ilustración 11: Pantalla de creación de un nuevo proyecto II.

En la siguiente pantalla, se seleccionará qué tipo de aplicación Android se quiere

desarrollar, en este caso “Phone and Tablet”, y el mínimo SDK con el que podrá ser
compilada, es decir, a partir de qué versión de Android la aplicación podrá ser ejecutada.
Para elegir el mínimo SDK habrá que tenerse en cuenta que, cuánto menor sea el
mínimo, más terminales podrán ejecutar tu aplicación, pero más difícil será la
compatibilidad con éstos, ya que algunas funciones usadas en versiones de Android más
modernas no están disponible en las versiones antiguas.
Para ayudarte a tomar la decisión, Google ofrece una gráfica en la que muestra a qué
porcentaje de terminales llegas usando un determinado nivel mínimo de SDK. Para
acceder a esta pantalla, se ha de pulsar en las letras azules “Help me choose”.

13
Ilustración 12: Pantalla de estadísticas de terminales disponibles por SDK mínimo.

Como podemos apreciar, con un SDK mínimo de 16, podremos acceder al 95,2% de los
terminales Android.
En la siguiente pantalla, el propio Android Studio, te permite elegir una plantilla para la
pantalla principal de tu aplicación. Para desarrollos más avanzados, o para tener ejemplos
sobre las implementaciones creadas por los desarrolladores de Android, puede ser
interesante abrir alguno de las ejemplos disponibles. En este caso, se elegirá la opción
“Empty Activity”, que generará la actividad con el código mínimo necesario.

14
Ilustración 13: Pantalla de creación de un nuevo proyecto III.

Por último, se deberá introducir el nombre la actividad creada y de la vista asociada a

dicha actividad. El resultado será la creación del proyecto por parte del entorno de
desarrollo. Si se hace click en el botón “Project” del menú lateral izquierdo, se abrirá la
ventana mostrada en la siguiente ilustración. El formato en que se muestra la estructura
del proyecto es posible cambiarlo pulsando en el botón que se encuentra resaltado. En
este caso se seleccionará la vista “Android”.
Ahora que ya se tiene un proyecto creado, se necesita entender la estructura de
directorios para poder continuar con el desarrollo.

15
Ilustración 14: Vista de la estructura de un proyecto vacío.

Carpeta Descripción

manifests Contiene el archivo manifest.xml que se encarga de definir

diferentes aspectos de la aplicación (permisos, nombre, icono
principal…).

java Contiene subdirectorios. Dos de ellos para almacenar los tests

de la aplicación y otro, en el que se encuentra nuestra actividad
principal, el destinado a almacenar todo el código java que se
vaya generando.

res Destinado a almacenar, en un listado de subdirectorios, los

archivos .xml y los complementarios al desarrollo, como
pueden ser imágenes, iconos, archivos de música o vídeo.

res/drawable Contiene las imágenes y archivos .xml destinados al uso de

éstas.

res/mipmap Contiene el icono principal de la aplicación.

res/layout Contiene los archivos XML de las vistas de la aplicación.

res/anim Contiene los archivos XML que definen las animaciones.

16
res/animator

res/color Contiene los archivos XML que definen listas de colores.

res/menu Contiene los archivos XML que definen los menús.

res/raw Contiene los archivos con formato distinto a XML.

res/values Contiene los archivos XML de recursos de la aplicación, entre

ellos, los archivos con los textos, los archivos con los estilos,
etc.

Android usa, en determinadas carpetas, un sistema de sufijos con el objetivo de poder

elegir, dinámicamente, unos elementos u otros, en función de las características del
terminal en el cual se esté ejecutando la aplicación, por ejemplo, para la ruta
res/drawable, es posible usar un sufijo que permita elegir distintas imágenes a mostrar en
función de la densidad de pantalla. Se podrá tener un icono lupa con diferentes
resoluciones dentro de cada directorio con el sufijo correspondiente (/drawable-ldpi,
/drawable-mdpi, /drawable-hdpi, /drawable-xhdpi, /drawable-xxhdpi).
Este comportamiento se reproduce también para res/layout (res/layout-land para usar las
vistas cuando el móvil se encuentre en posición apaisada), /res/values (para elegir el
idioma en que mostrar los textos), etc. Se puede encontrar la documentación completa en
la página oficial de desarrollo Android.
Además de los directorios comentados anteriormente, es importante destacar los
siguientes archivos.

AndroidManifest.xml
Este archivo se encarga de proporcionar información a Android sobre cómo ejecutar la
aplicación. Entre otras cosas se encarga de nombrar el paquete de la aplicación, describir
las actividades que conforme la app, declarar los permisos que debe tener la aplicación,
etc.
En la siguiente ilustración se puede ver un ejemplo de una aplicación que cuenta con una
actividad que se conecta a internet y hace uso del GPS.

17
 Ilustración 15: Archivo AndroidManifest.xml.

En la referencia 1 del manifest, se encuentran los permisos que usa la aplicación. En esta
lista de la página oficial de Google se pueden encontrar todos los permisos.
En la referencia 2 se define el atributo “application” dentro del cual se definirán entre otros
elementos, las actividades de la aplicación, como por ejemplo, la que se muestra en la
sección 3.
Por último, en la referencia 3, como ya se ha comentado anteriormente, se muestra una
actividad de nombre MainActivity.

build.gradle
Este archivo que se genera automáticamente cuando se crea un proyecto, contiene las
características usadas a la hora de compilar el APK (ejecutable de la aplicación Android),
por ejemplo, entre otras contiene la versión de la aplicación, el id que se forma juntado el
nombre del dominio más el nombre de la app, etc.
La sección dependencies se encarga de gestionar, gracias a la herramienta Gradle, el uso
de las librerías externas al proyecto.

18
 Ilustración 16: Archivo build.gradle.xml.

PARA PROFUNDIZAR
Gradle.
Lista de permisos.
Agrupación de los tipos de recursos.

19
3 Componentes y archivos principales de una aplicación
Android

En las aplicaciones Android se pueden destacar varios componentes importantes, que

relacionados entre ellos, representan la estructura de alto nivel de una aplicación. Por
ejemplo, el esquema de la siguiente ilustración, podría representar un modelo básico para
una aplicación que pida una lista de datos a un servidor.

Ilustración 17: Modelo básico de una aplicación Android.

En el esquema de la ilustración anterior, se pueden apreciar 6 componentes distintos que

interaccionan ellos.

20
Vistas
Son las clases que representan los componentes que se usan en la interfaz de usuario.
Aunque son desarrollados en Java, al igual que el resto del proyecto, Android permite a
los desarrolladores la interacción con estos a través de lenguaje XML. Además, el entorno
oficial de Android, Android Studio, cuenta con una herramienta “Drag and Drop”
(arrastrado y soltado) que permite la creación de interfaces de usuario de manera visual.

Ilustración 18: Herramienta Drag and Drop de Android Studio.

En las vistas se ha de representar información estática y dinámica.

La información estática es aquella que no cambia independientemente del estado de la

aplicación. Esta información es asignada en el momento de la creación de las vistas con
XML en la fase de desarrollo del proyecto. Por ejemplo, las opciones en el menú de
navegación, por norma general, en cualquier aplicación son siempre las mismas: “Inicio”,
“Mensajes”, “Configuración”, etc.

21
La información dinámica es aquella sensible al cambio en función del estado de la
aplicación. A la hora de la construcción de las vistas en XML, se deja la estructura de la
información preparada para que, dinámicamente, se vaya rellenando en función del uso
que haga el usuario en la aplicación. Por ejemplo, para una aplicación que requiera una
identificación del usuario, por ejemplo Facebook, el nombre de usuario en la pantalla
“Perfil”, será diferente en función del usuario al que se esté visitando. Son las actividades
las encargadas de realizar dicha asignación dinámica.

Adaptadores
En Android, se trabaja con información que, aparte de ser dinámica porque no sabes qué
datos te van a llegar, también lo es porque no sabes cuántos datos te van a llegar. Por
ejemplo, en una aplicación que los usuarios se pudieran mandar mensajes entre ellos, se
daría este caso al abrir la pantalla de conversaciones. Los adaptadores permiten hacer
genérica la representación de este tipo de información independientemente del tamaño de
la lista que se haya de mostrar. Otra característica de los adaptadores, que nos ofrece
mucha flexibilidad a la hora de mostrar la información, es que permite diferenciar
visualmente cada elemento de la lista, es decir, permite tener listas de elementos
heterogéneos.

Los adaptadores son creados y llamados en las actividades. Éstas se encargan de

pasarle los datos y los adaptadores se encargan de cómo representarlos.

Modelo de Datos
Son las clases que representan las entidades de nuestra aplicación. Cuando llegan los
datos del servidor, son procesados y almacenados como objetos. Por ejemplo, cuando un
usuario entra en la pantalla de sus conversaciones, el servidor manda una lista con los
resultados, se procesa y se crean los objetos Conversacion (o cualquier otro nombre que
le demos a la clase que represente las conversaciones) que, posteriormente, serán
procesados por la actividad.

22
Tareas o Tasks
Las tareas o tasks, son las encargadas de realizar peticiones HTTP al servidor. Además
de realizar la llamada y enviar los datos necesarios, se encargan de recoger las
respuestas con la información correspondiente. Estas respuestas pueden ir desde un
mensaje de error, hasta información que se deba representar en la aplicación.

En algunos de los casos dónde la información necesite ser guardada, las tareas se
encargarán de crear y rellenar el modelo de datos correspondiente con la información
recibida.

Actividades
Una actividad es un componente que proporciona una vista que abarca toda la pantalla
del dispositivo y que se crea con el objetivo de realizar una acción.

Las actividades crearán las vistas y las rellenarán con la información extraída de los
modelos de datos; en el caso de información dinámica podría darse el caso de necesitar
adaptadores. Si se requiere información del servidor, se encargarán de crear la tarea
correspondiente y la gestión de la devolución de los datos.

Fragmentos
Un fragmento representa una porción de vista o de comportamiento en una actividad. Los
fragmentos pueden realizar las mismas acciones que las actividades. Se podría decir, que
un fragmento es una sección modular de una actividad, con capacidad de ser reutilizable
en otras actividades.

En la aplicación, los fragmentos son usados como pestañas. En la actividad “Perfil”,

representada en la siguiente ilustración, se puede comprobarlo. Entre otras, aparecen las
pestañas “Seguidores”, “Seguidos” e “Información”. Cada una se representa con un
fragmento dentro de la actividad que los crea.

23
Ilustración 19: Fragmentos usados como pestañas.

En la siguiente ilustración, se presenta un ejemplo de cómo circula la información a través

de los componentes de una aplicación que muestra una lista de mensajes tras haber
realizado la petición al servidor que los aloja.

24
Ilustración 20: Diagrama que representa el flujo de información a través de los componentes de la app.

25
4. Desarrollando una app sencilla
Ahora que ya se conoce el entorno de desarrollo y cómo crear un proyecto nuevo, es hora
de crear la primera aplicación. El objetivo de este capítulo no es comprender todos los
componentes creados, ni aprenderse todas las distintas posibilidades de implementación,
sino hacerse una idea general del funcionamiento de una aplicación básica en Android.

Para este primer contacto, se pretende crear dos actividades. La primera consta de tres
elementos. Un botón, un texto y un campo para recibir un texto introducido por teclado por
parte del usuario. La segunda actividad, mostrará por pantalla el texto introducido en la
primera.

1 Crear el proyecto
En primer lugar se debe crear el proyecto cómo ha sido explicado en las secciones
anteriores. Como la actividad principal va a ser muy simple, es recomendable elegir la
opción “Empty Activity” en el formulario de elección de la actividad principal al crear el
nuevo proyecto. Se puede dar el nombre que se quiera a la actividad, por defecto se
llamará MainActivity. En el ejemplo aquí expuesto, se llamará SaludoActivity. El estándar
establece, sin ser obligatorio pero sí recomendable, que las actividades usen la
nomenclatura CamelCase y se le añada al final del nombre “Activity”.

Por defecto, Android Studio crea la vista asociada a la actividad, tomando como base el
nombre de dicha actividad para nombrar a la vista. Separa las palabras con ‘_’ siendo la
primera “activity”. En este caso: “activity_saludo.xml”

2 Modificar la vista activity_saludo

Como ya se ha comentado anteriormente, la vista se crea bajo el directorio
/res/layout/activity_saludo.xml. Cuando se abre la vista, veremos que Android Studio por
defecto ha generado algo de código. De momento se borrará este código para crear el
que se adapte la problema en cuestión.

El objetivo en esta vista es tener tres elementos ordenados de forma vertical: texto, input y
botón.

26
- Texto: representado con el componente TextView. Describirá al usuario la acción que
debe realizar.

- Input: representado con el componente EditText. Se encargará de recoger el texto que

el usuario introduzca por teclado.

- Botón: el componente tradicional para representar los botones es Button, aunque

cualquier otro componente puede simular su comportamiento. Se encargará de recibir la
orden para iniciar el saludo y gestionar la acción a realizar.

En la siguiente ilustración se mostrará una posible implementación de la interfaz. Cada

elemento a destacar es referenciado en la imagen y explicado a continuación.

Ilustración 21: Interfaz y código de la aplicación.

Referencia 1
La ventana que se muestra a la derecha de la pantalla es una representación aproximada
de como se verá la ejecución del código en el terminal. Por ejemplo, en este caso,
EditText debería mostrar una linea debajo del texto que sugiere al usuario la acción a
realizar. Para activar la previsualización se deberá pulsar en el botón que se encuentra en
la parte derecha de la pantalla con el texto “Preview”.

27
Referencia 2
La ilustración se corresponde con la vista para editar textualmente la interfaz. Es posible
cambiar a la vista de edición visual pulsando en el botón “Design” de la parte inferior de la
pantalla. Esta opción es menos recomendada ya que es menos potente que la vista
textual.

Referencia 3
Esta referencia muestra el primer elemento que encontramos en nuestra vista. Todas las
vistas sólo pueden tener un único elemento raíz, es decir, todos los demás elementos
deben encontrarse dentro de un elemento padre. Los LinearLayout sirven para organizar
los componentes de manera secuencial, de forma horizontal o vertical, en función del
atributo que se encuentra en la línea 8 “android:orientation”. Es decir, todos los
elementos que se coloquen dentro de este LinearLayout se irán colocando uno encima de
otro. Si nos fijamos, existe un espacio entre todos los elementos y los bordes de la
pantalla, esto se debe al atributo de la línea 9 “android:layout_margin=’16dp’”, que
obliga a dejar una separación de 16dp, entre cada uno de los cuatro bordes del layout y
sus elementos.

Por último, cabe destacar los atributos “android:height” y “android:width”. Se

encargan de dar las dimensiones del elemento a lo ancho y a lo largo. En este caso se les
asigna el valor “match_parent” que viene a decir “agrándate hasta ocupar el máximo
disponible por tu elemento padre”. En este caso no hay elemento padre así que se
ajustará al máximo de ancho y largo de la pantalla.

Referencia 4
Esta referencia explicará el componente TextView. Su función es mostrar un determinado
texto asignado con el atributo “android:text”. Cuenta también con los atributos
“android:height” y “android:width” con el valor “wrap_content” que a diferencia
de “match_parent”, viene a decir: “agrándate al mínimo necesario”.

Referencia 5
En esta referencia se quiere hablar del componente EditText. Actúa como un clásico input
al que se le asigna un texto que sugiera la acción (atributo “android:hint”), un id

28
(atributo “android:id”) ya que en la actividad necesitaremos obtener el texto que ha
introducido el usuario, y unas dimensiones con los mismos atributos y valor que el
TextView: “android:height” y “android:width” con “wrap_content”.

Referencia 6
Componente Button tiene que la apariencia de botón. Al igual que en los componentes
anteriores, se le asigna un id, para capturar la acción de “click”, una anchura y altura y un
texto.

3 Modificar la actividad SaludoActivity

Cuando se crea la actividad, si se ha seleccionado la opción de “Empy Activity”,
tendremos una clase java parecida a la de la siguiente ilustración.

Ilustración 22: Actividad vacía.

Cuando se ejecuta una actividad, Android entra en el método auto-generado “onCreate” y,

como vemos en la línea 11, asigna la vista que ya hemos modificado a dicha actividad.

El siguiente paso, una vez que ya se ha asignado la vista, será buscar el EditText para
obtener el texto del usuario y el botón para capturar el “click”.

29
Ilustración 23: Actividad principal.

Para asociar los componentes visuales definidos en la vista, se utilizará el método

findViewById(id del componente). Este método devuelve un objeto de tipo View sobre el
que habrá que hacer un casting al tipo correspondiente. Si el id introducido no fuera
encontrado en la vista asociada a dicha actividad, se devolvería “null”.

En la línea 30 se define el comportamiento que deberá ejecutarse cuando el botón reciba

la pulsación. Se consigue por medio del método setOnClickListener y de las clases
anónimas de java. La sección de código dentro del método onClick, será la ejecutada
cuando se pulse el botón.

En la línea 34, se accede al método getText del componente EditText. Devolverá el texto
(que habrá que transformar a String) introducido por el usuario.

El siguiente paso sería crear la nueva actividad para mostrar el saludo al usuario.

30
4 Crear la actividad MostrarSaludoActivity
Seleccionar en el menú superior File – New – Activity – Empty Activity, tal y como se
muestra en la siguiente ilustración.

Ilustración 24: Menú para crear un nueva actividad.

5 Editar la vista activity_mostrar_saludo

Esta vista ha de mostrar un texto con un formato parecido al siguiente: “Hola Juan ¿qué
tal?” siendo “Juan” el nombre que el usuario haya introducido por teclado en la actividad
anterior.

31
Ilustración 25: Código de la interfaz de SaludoActivity.

Ha diferencia de la vista anterior, el layout raíz tendrá una disposición horizontal, para
alojar los tres TextViews necesarios. El primero de ellos mostrará el mensaje “Hola” y
dejará un espacio a su derecha. El segundo de ellos mostrará el nombre que el usuario
haya escrito. Este nombre será asignado dinámicamente, por ello es necesario asignarle
un id de manera que podemos buscarlo en la actividad. Por último, el tercer TextView,
mostrará el mensaje “¿Qué tal?”.

6 Editar la actividad SaludoActivity

Ahora que ya se ha creado la actividad MostrarSaludoActivity, se puede completar el
código de SaludoActivity.

Ilustración 26: Listener que lanza la actividad que muestra el saludo.

32
Se ha de crear un objeto de la clase Intent, que recibe como primer parámetro el contexto
de la clase desde que se lanza (NombreDeLaClase.this) y la clase que se debe ejecutar
(ClaseAEjecutar.class). A este intent, se le pueden pasar parámetros en la clase que llama
para ser recogidos en la clase llamada con el método putExtra(“clave”, valor). Por último,
se usa el método startActivity(intent) para lanzar la nueva actividad.

7 Editar la actividad MostrarSaludoActivity

Se deberá recoger el nombre pasado en el intent (usando la clave correspondiente, en el
caso aquí mostrar “nombre”), asociar el TextView en el que mostraremos el nombre
escrito por el usuario con la actividad y por último mostrar dicho nombre.

Ilustración 27: Actividad MostrarSaludo.

8 Ejecutar el proyecto
Para poder ejecutar el proyecto o bien se tiene o terminal Android y se conecta al PC, o
bien se crea una máquina virtual.

33
Para crear una máquina virtual desde Android Studio, en primer lugar se pulsará sobre el
ADV Manager que aparece en la siguiente ilustración.

Ilustración 28: Botón AVD Manager.

En la pantalla resultante se deberá de pulsar en el botón “Create Virtual Device...”

Ilustración 29: Pantalla para crear una máquina virtual.

Se seleccionará el dispositivo a emular deseado y se pulsará “Next”.

34
 Ilustración 30: Pantalla para la elección de un dispositivo virtual I.

Se elegirá una versión de Android para la máquina virtual y se pulsará “Next”

Ilustración 31: Pantalla para la elección de un dispositivo virtual II.

35
Por último se le podrá asignar un nombre al dispositivo virtual antes de crearlo.

Ilustración 32: Pantalla para la elección de un dispositivo virtual III.

Ahora que ya lo tenemos creado, solo falta ejecutarlo.

Ilustración 33: Pantalla para la elección de un dispositivo virtual IV.

Si todo ha ido bien, tenemos la máquina virtual funcionando y, al pulsar sobre el botón
verde con forma de “play”, aparecerá un diálogo donde nos dejará elegir la máquina

36
virtual creada. Si deseamos usar un dispositivo real, deberemos conectar por medio de un
cable USB nuestro terminal Android y habilitar las “opciones de desarrollador” que se
encuentran en la configuración del dispositivo. Se puede obtener más información en la
guía oficial de Android Developers.

Ilustración 34: Ejecución del proyecto.

9 Probar la aplicación
Como ya se ha explicado anteriormente, se introducirá un nombre, se pulsará en
“SALUDAR” y será mostrada en la actividad MostrarSaludoActivity. El resultado debería
ser el mostrado en la siguiente ilustración.

Ilustración 35: Ejecución de la aplicación.

37
EJERCICIOS
1. Realizar los cambios necesarios en activity_saludo para que el botón aparezca a la
derecha del EditText.

2. Realizar una aplicación similar donde en la primera actividad se pida la edad y en la

segunda se muestre un mensaje del estilo: “Tienes X años”.
* EditText tiene un atributo para restringir el tipo de entrada de datos:
android:inputType="tipo"

* Al recibir el texto del EditText, siempre se recibe en formato String, independientemente

del tipo de input recibido. Convertir dicho texto recogido por teclado a tipo int.

3. Modificar la aplicación Saludo o SaludoErj1 para que al introducir el nombre valide que
no sea vacío. Si es vacío, mostrar un mensaje al usuario usando el componente no visto,
pero que será explicado más adelante Toast. Si no es vacío, lanzar la siguiente actividad
igual que en los ejercicios anteriores.

* El componente Toast permite lanzar mensajes emergentes al usuario. Suelen ser

usados para notificar de una acción de o un error. Código para mostrar un Toast:
Toast.makeText(SaludoActivity.this, "No ha insertado ningún
nombre", Toast.LENGTH_SHORT).show();

38