Primer Acercamiento AndroidStudio

See discussions, stats, and author profiles for this publication at: https://www.researchgate.
net/publication/354474559
Primer acercamiento al Android Studio
Chapter · June 2020
CITATIONS READS
0 693
1 author:
Marlon Mederos Corrales

Universidad Tecnológica de la Habana, José Antonio Echeverría
5 PUBLICATIONS 0 CITATIONS
SEE PROFILE
All content following this page was uploaded by Marlon Mederos Corrales on 09 September 2021.
The user has requested enhancement of the downloaded file.

Primer acercamiento
al
Android Studio
MSc. Marlon Mederos Corrales
Universidad Tecnológica de La Habana

“José Antonio Echeverría”, CUJAE
Centro de Investigaciones
Hidráulicas, CIH
Monografía, CUJAE, 2021
ISBN: 978-959-261-605-9
Resumen
La programación es un maravilloso universo, en el que el programador puede llevar a cabo,
infinidades de proyectos, de acuerdo con sus capacidades e imaginación. Las aplicaciones para
dispositivos móviles ofrecen la ventaja que, al ser instaladas en un teléfono, se encuentran muy cerca
del usuario, por ende, deben ser idealizadas con esta premisa. Android Studio ofrece, no sólo la
posibilidad de crear un proyecto útil, sino que brinda, además, una idea muy acercada del producto
final.
El objeto que dio luz a la siguiente publicación, es brindar a los principiantes, una herramienta que
les permita acercarse al fascinante mundo de la programación. No se profundizan temas más allá de
lo necesario, más bien, se aborda lo esencial de cada contenido, para no abrumar al lector con tópicos
más especializados. Se han empleado las denominaciones en inglés, con el fin de no inducir errores
en la búsqueda bibliográfica del lector, producto de traducciones. Los contenidos están enfocados en
el aprendizaje gradual, no sólo del software que es objeto de estudio, sino del lenguaje de
programación Java. No se abordan por separado las líneas de código y el entorno de programación,
sino que se combinan constantemente, como un único tema. Se profundiza en la arquitectura interna
del Android Studio y se crean aplicaciones a partir del conocimiento de su estructura.
Palabras claves: Android Studio, aplicaciones, dispositivos móviles, Java, programación.
Abstract
Programming is a wonderful universe, in which the programmer can carry out an infinite number
of projects, according to his abilities and imagination. Applications for mobile devices offer the
advantage that, when installed on a phone, they are very close to the user, therefore, they must be
idealized with this premise. Android Studio offers, not only the possibility of creating a useful project,
but also offers a very close idea of the final product.
The object that gave birth to the following publication is to provide beginners with a tool that
allows them to approach the fascinating world of programming. Topics are not delved beyond what
is necessary, rather, the essential of each content is addressed, so as not to overwhelm the reader with
more specialized topics. The names in English have been used, in order not to induce errors in the
bibliographic search of the reader, product of translations. The contents are focused on gradual
learning, not only of the software that is the object of study, but of the Java programming language.
The lines of code and the programming environment are not discussed separately, but are constantly
combined, as a single topic. The internal architecture of Android Studio is explored, and applications
are created based on the knowledge of its structure.
keywords: Android Studio, applications, mobile devices, Java, programming.
I
Índice de contenido
Introducción .................................................................................................................... 1
1. Android Studio ............................................................................................ 2
1.1 Glosario de términos de Android Studio ......................................................................... 3
1.2 Creación de un nuevo proyecto y de una activity............................................................ 7
1.3 Creación de un Android Virtual Device (AVD)............................................................ 11
1.3.1 Emulación y depuración del proyecto ................................................................... 14
1.4 Carpetas y subcarpetas del sistema ............................................................................... 16
1.4.1 Carpetas del sistema: ............................................................................................. 16
1.4.2 Subcarpetas del sistema:........................................................................................ 18
1.5 Interfaz de usuario y archivos .xml ............................................................................... 26
1.5.1 Palette .................................................................................................................... 28
1.5.2 Component Tree .................................................................................................... 34
1.5.3 Properties............................................................................................................... 35
1.6 Inserción de distintos tipos de archivos ......................................................................... 36
1.6.1 Inserción de imágenes y cambio del ícono ............................................................ 38
1.6.2 Inserción y reproducción de archivos de audio ..................................................... 42
1.6.3 Inserción y reproducción de videos ....................................................................... 44
1.7 Navegación entre activities ........................................................................................... 46
1.7.1 Creación de una nueva activity ............................................................................. 46
1.7.2 Navegación entre activities ................................................................................... 48
1.8 Diferentes técnicas dentro de Android Studio ............................................................... 50
1.8.1 Bloqueo de la orientación de la pantalla ............................................................... 50
1.8.2 Cambio de la fuente de la letra .............................................................................. 51
1.8.3 Creación de advertencias y cuadros de diálogo ..................................................... 53
1.8.4 Guardar un texto y recuperarlo tras cerrar la aplicación ....................................... 60
II
1.8.5 Trabajo con los RadioButton ................................................................................. 63
1.8.6 Spinner .................................................................................................................. 64
1.8.7 Validación de campos vacíos ................................................................................ 66
Conclusiones .................................................................................................................. 67
Bibliografía .................................................................................................................... 68
III
Índice de Figuras
Figura 1: Software de programación para dispositivos móviles Android Studio........................... 2
Figura 2: Ventana principal en la inicialización de Android Studio. ............................................. 7
Figura 3: Ventana de configuración del proyecto. ......................................................................... 8
Figura 4: Ventana de selección de tipo de dispositivo y de versión android. ................................ 8
Figura 5: Ventana de selección de tipo de activity inicial. ............................................................. 9
Figura 6: Ventana de opciones de la activity. ................................................................................ 9
Figura 7: Entorno Android Studio. .............................................................................................. 10
Figura 8: Ubicación del AVD Manager. ...................................................................................... 11
Figura 9: Creación de una máquina virtual. ................................................................................. 11
Figura 10: Selección del tipo de dispositivo virtual. .................................................................... 12
Figura 11: Selección de la versión android de la máquina virtual. .............................................. 12
Figura 12: Ubicación del SDK Manager...................................................................................... 13
Figura 13: Configuración de la máquina virtual. ......................................................................... 13
Figura 14: Lista de máquinas virtuales instaladas en Android Studio. ........................................ 13
Figura 15: Ubicación del emulador de aplicaciones. ................................................................... 14
Figura 16: Selección de la máquina virtual para emular la aplicación......................................... 14
Figura 17: Ejemplo de un dispositivo virtual para emular una aplicación. .................................. 15
Figura 18: Depuración mediante la herramienta LogCat. ............................................................ 15
Figura 19: Carpetas del sistema. .................................................................................................. 16
Figura 20: Creación de la carpeta assets. ..................................................................................... 18
Figura 21: Muestra de las subcarpetas del sistema. ..................................................................... 19
Figura 22: Creación de la subcarpeta anim. ................................................................................. 20
Figura 23: Creación de una variación del layout al girar la pantalla............................................ 21
Figura 24: Opción que permite ver la interfaz cuando se gira la orientación del dispositivo. ..... 21
Figura 25: Creación de la subcarpeta raw. ................................................................................... 22
Figura 26: Línea de código referida a la view del cual se quiere reproducir el style. .................. 23
Figura 27: Ubicación del archivo ".xml" que contiene los diferentes styles guardados............... 23
Figura 28: Ejemplo de cómo crear y modificar un style. ............................................................. 24
Figura 29: Ubicación de los styles guardados para aplicarlos a una view. ................................... 24
Figura 30: Creación de la subcarpeta font. ................................................................................... 25
Figura 31: Secciones del editor de diseño gráfico. ...................................................................... 27
Figura 32: Pestaña Palette............................................................................................................ 28
Figura 33: Carpeta Layouts de la pestaña Palette. ....................................................................... 29
IV
Figura 34: Carpeta Widgets de la pestaña Palette. ....................................................................... 30

Figura 35: Carpeta Text Fields de la pestaña Palette. .................................................................. 33
Figura 36: Carpeta Containers de la pestaña Palette. .................................................................. 33
Figura 37: Pestaña Component Tree. ........................................................................................... 34
Figura 38: Pestaña Properties. ..................................................................................................... 35
Figura 39: Opciones de copiado de una imagen. ......................................................................... 38
Figura 40: Inserción de un contenedor ImageView. ..................................................................... 39
Figura 41: Selección de la imagen a insertar. .............................................................................. 39
Figura 42: Ajustes a la imagen insertada. .................................................................................... 40
Figura 43: Ubicación de la herramienta “Image Asset” para cambiar el ícono. .......................... 41
Figura 44: Opciones para el cambio de ícono. ............................................................................. 41
Figura 45: Vista preliminar del nuevo ícono................................................................................ 42
Figura 46: Ventana de comprobación de las características del archivo de audio. ...................... 42
Figura 47: Ubicación del archivo de audio en la subcarpeta raw. ............................................... 43
Figura 48: Ubicación de la línea de código para la inserción de un audio. .................................. 43
Figura 49: Ventana de comprobación de las características del archivo de video. ...................... 44
Figura 50: Ejemplo del uso de un VideoView. ............................................................................. 45
Figura 51: Ubicación de la línea de código para la inserción de un video. .................................. 45
Figura 52: Creación de una nueva activity. .................................................................................. 46
Figura 53: Asignación del nombre a la nueva activity. ................................................................ 47
Figura 54: Ubicación en la nueva activity. ................................................................................... 47
Figura 55: Modificación del archivo Android Manifest debido a una nueva activity. ................. 48
Figura 56: Ubicación de la herramienta de navegación entre pantallas Navigation Editor. ........ 49
Figura 57: Resultado del empleo del Navigation Editor. ............................................................. 49
Figura 58: Ubicación de la línea de código para bloquear la orientación de la pantalla. ............. 50
Figura 59: Alternativa para importar una class. ........................................................................... 51
Figura 60: Resultado de la importación de la class “ActivityInfo”. ............................................ 51
Figura 61: Ventana de comprobación de las características del archivo de fuente de letra. ........ 52
Figura 62: Ubicación de la línea de código para la inserción de un archivo de fuente de letra. .. 53
Figura 63: Ubicación del código para cerrar una class. ............................................................... 56
Figura 64: Inserción de la ImageView en la interfaz. ................................................................... 57
Figura 65: Creación del nuevo layout. ......................................................................................... 58
Figura 66: Diseño de la interfaz a mostrar en el AlertDialog. ..................................................... 58
Figura 67: Ubicación de la view contenedora del método de llamada del AlertDialog. .............. 59
V
Figura 68: Interfaz para guardar y cargar un texto. ...................................................................... 60

Figura 69: Ubicación de las variables para conservar un texto tras cerrar la aplicación.............. 61
Figura 70: Ubicación del Spinner. ............................................................................................... 64
Figura 71: Localización de las variables a crear para la inserción de un Spinner........................ 64
VI
INTRODUCCIÓN
El teléfono móvil, recurrentemente, se encuentra al alcance de su propietario, siendo uno de los

objetos de mayor contacto con las personas y, justamente esto, debe ser tenido en cuenta para la
concepción de las aplicaciones. Android Studio es el entorno de desarrollo integrado (IDE) oficial
para el desarrollo de apps para Android y está basado en IntelliJ IDEA; además, ofrece una API muy
completa que contiene una gran cantidad de documentación.
Al ser el entorno de desarrollo de Android, uno de software libre, esta plataforma se ha visto
favorecida, debido a que el desarrollador tiene la posibilidad de descargarlo de la web oficial, sin
coste alguno. Al incluir en una base de datos, una gran cantidad de servicios, la información de las
aplicaciones se mantiene actualizada. Por otro lado, este sistema operativo, está enfocado en
dispositivos con poca capacidad de proceso, poca batería y poca memoria.
El diseño de Android es adaptable a diversos tipos de hardware, por ejemplo, la interfaz de usuario
es diseñada en XML. Esto que permite que una misma aplicación, sea ejecutada en un SmartWatch
con una pantalla reducida o en un SmartTv. Este software posibilita el alcance de una alta calidad de
gráficos y sonidos e incorpora los tipos de archivos más comunes en audio y video.
El presente trabajo, aborda la arquitectura interna del Android Studio y la composición de los
proyectos creados. Se conceptualizan las componentes gráficas y se detalla la interfaz del usuario.
Por otro lado, se pincelan diferentes aspectos de la programación en Java, a partir de su relación con
el entorno del software. Terminada la lectura, el programador estará en condiciones de crear
aplicaciones, empleando diversas técnicas durante el desarrollo.
1
1. ANDROID STUDIO
El sistema operativo de código abierto (open source), android, principalmente es programado en

el lenguaje de programación Java y su núcleo se basa en Linux. Android fue comprado en el año
2005 por Google y no sólo se instala en teléfonos celulares, sino también en tabletas, televisores,
relojes...entre otros, por lo que existen muchas posibilidades para su empleo.
Como es un sistema operativo de “open source”, ha dado origen a una comunidad de desarrollo,
donde los desarrolladores se ahorran la programación de entornos para dispositivos específicos, más
bien, esta labor la pueden alcanzar desde cualquier plataforma y para cualquier dispositivo móvil. La
existencia de herramientas de programación libres de costo, han causado la presencia de innumerables
aplicaciones que, mejoran la experiencia del usuario y derivan en la clave del éxito.
Figura 1: Software de programación para dispositivos móviles Android Studio.
Android Studio es el primer software creado por Google para desarrollar aplicaciones android, por
ende, es un programa originado por los propietarios del sistema operativo. Cuenta con un robusto
editor basado en IntelliJ IDEA y un compilador gradle, que es el encargado de generar las carpetas y
descargar todos los elementos necesarios, de esta forma, se efectúan configuraciones personalizadas
mediante una compilación más estable. Este software cuenta con una Interfaz muy amigable y con un
editor gráfico que permite crear interfaces, incluso sin el empleo de códigos.
Se debe descargar e instalar el compilador de Java, la máquina virtual (Android Virtual Device) y
el archivo “.SDK”. Una vez que se han situado las herramientas necesarias para que funcione
correctamente este programa, se procede a la creación del primer proyecto android. A continuación,
se definen una serie de términos imprescindibles para la comprensión del documento.
2
1.1GLOSARIO DE TÉRMINOS DE ANDROID STUDIO
• Sistema operativo android: Es un sistema operativo de código abierto (open source), concebido
principalmente en el lenguaje de programación Java, que tiene su núcleo basado en Linux.
• Open source: Un sistema operativo de “open source”, se refiere a que es de código abierto o de
libre acceso. La existencia de herramientas de programación libres de costo, han causado la
presencia de innumerables aplicaciones que, mejoran la experiencia del usuario y derivan en la
clave del éxito.
• Android Studio: Android Studio es el primer software creado por Google para desarrollar
aplicaciones android, por ende, es un programa originado por los propietarios del sistema
operativo. Cuenta con un robusto editor basado en IntelliJ IDEA y un compilador gradle, que es
el encargado de generar las carpetas y descargar todos los elementos necesarios, de esta forma,
se efectúan configuraciones personalizadas mediante una compilación más estable. Este software
cuenta con una Interfaz muy amigable y con un editor gráfico que permite crear interfaces, incluso
sin el empleo de códigos.
• Java: Existen muchos lenguajes de programación para desarrollar en Android, pero Java es el
lenguaje que se recomienda por parte de Google. Aunque la programación nativa de Android es
en Java, Android no usa Java “puro”. La escritura y el desarrollo de una aplicación Android es
muy parecida a un proyecto Java normal, no así a la hora de compilar y ejecutar el código.
• Gradle: Una de las principales ventajas de usar Android Studio es la de poder hacer uso de su
compilador. Gradle es una herramienta para automatizar la construcción de los proyectos, por
ejemplo, manejar de forma fácil las dependencias, disponer de varios entornos para un mismo
proyecto, para tareas de compilación, testing, empaquetado y despliegue. Gradle usa “Domain
Specific Language” (DSL) basado en Groovy para declarar la forma de construir el proyecto.
Para configurarlo simplemente se escribe código en Groovy, que es muy parecido a Java. Es muy
flexible en para configurar, disponiendo de tareas ya armadas por defecto. Es un proyecto Open
Source licenciado bajo Apache Software Licence (ASL).
• SDK (Software Development Kit): Un SDK es un conjunto de herramientas y programas de
desarrollo que permite al programador crear aplicaciones para un determinado paquete de
software, estructura de software, plataforma de hardware, sistema de computadora, consulta de
videojuego, sistema operativo o similar. Las aplicaciones Android nativas se desarrollan en el
lenguaje Java usando este kit. Proporciona las bibliotecas API y las herramientas para la creación
y depuración de aplicaciones Android. Permite poder utilizar nuestro dispositivo desde el
ordenador en vez de usar el emulador.
3
• API: Interfaz de Programación de Aplicaciones, es el conjunto de funciones y procedimientos

que ofrece cierta biblioteca para ser utilizado por otro software como una capa de abstracción.
• IDE: Entorno de desarrollo integrado, es un programa informático compuesto por un conjunto
de herramientas de programación.
• App: Abreviatura de aplicación móvil.
• Android Virtual Device (AVD): Es considerado como un paso natural en la creación de
aplicaciones y consiste en probar las mismas en dispositivos virtuales, antes de lanzarlas a
dispositivos reales, mediante el “SDK” de Android Studio.
• LogCat: Herramienta depuradora, que debe ser empleada una vez que se ha terminado la
aplicación, con el fin de encontrar cualquier error y darle solución de manera rápida. La función
del LogCat no es detectar errores dentro del código de programación, pues para esto, está el
propio Android Studio; más bien esta herramienta, muestra errores que se producen únicamente
cuando la aplicación se está ejecutando.
• Carpetas del sistema: Dentro de la raíz “app”, existen 4 carpetas principales: manifests, java, res
y assets, esta última no viene por defecto, sino que hay que crearla.
- Carpeta manifest: Esta carpeta almacena el archivo AndroidManifest.xml.
- Carpeta java: En esta carpeta se encuentra el archivo de extensión “.java”, en el que se
concibe la programación de cada activity.
- Carpeta res: Carpeta donde se almacenan lo recursos (resources) de la aplicación, como son
audios, imágenes, videos, los textos en uno o varios idiomas, dimensiones, estilos, colores,
animaciones...entre otros.
- Carpeta assets: Carpeta en la que se pueden alojar los demás ficheros auxiliares para el
desarrollo de la aplicación, como distintas fuentes de letras y archivos pequeños.
• Subcarpetas del sistema: Las subcarpetas permiten diferenciar el lugar de almacenamiento de
ficheros de categorías similares. En la siguiente imagen, son mostradas algunas subcarpetas y,
aunque no aparecen todas, son una muestra de las más empleadas.
- Subcarpeta com.example.company_domain.application_name: Se ubica dentro de la
carpeta java y almacena el archivo “.java”.
- Subcarpeta anim: Se ubica dentro de la carpeta res y en esta subcarpeta se pueden colocar
diferentes efectos destinados a objetos como imágenes o botones. No viene por defecto, razón
por la que hay que crearla.
- Subcarpeta drawable: Se ubica dentro de la carpeta res y es en esta subcarpeta, donde se
almacenan las imágenes o archivos “.xml” que definen imágenes.
4
- Subcarpeta layout: Se ubica dentro de la carpeta res y en esta subcarpeta se almacena los
archivos “.xml” que contienen la interfaz visual de cada pantalla.
- Subcarpeta menú: Se ubica dentro de la carpeta res y mediante el recurso “Menu” se
almacenan elementos de los menús o de la barra de acciones, como la ActionBar.
- Subcarpeta raw: Se ubica dentro de la carpeta res y es la subcarpeta en la que se pueden
alojar audios y videos. Admite archivos mayores de 1 megabyte. No sale por defecto, sino
que hay que crearla.
- Subcarpeta values: Se ubica dentro de la carpeta res y mediante el recurso “Values” se
almacenan diferentes tipos de archivos de extensión “.xml”, como styles, dimens, strings…
- Subcarpeta font: Se ubica dentro de la carpeta assets y en esta subcarpeta se pueden alojar
fuentes de letras. No sale por defecto, sino que hay que crearla.
• Android Mannifest: Es el archivo, en lenguaje XML, en el que se almacena la configuración de
la aplicación, se insertan activities y se asignan permisos antes de la ejecución del proyecto. El
“Manifests” contiene información esencial como nombre, versión, ícono de la apk…entre otros,
pero a la vez contiene los componentes básicos de la aplicación, que el sistema operativo se
encarga de instanciar. Estos componentes son Activity, Services, Broadcast Receiver y Content
Provider.
• Layout: El layout es el diseño que define la estructura visual del proyecto, es el ambiente de
programación donde se generará la interfaz gráfica de la aplicación, relacionando las diferentes
activities.
• Activity: Una activity es el entorno de la aplicación, es la combinación de los elementos gráficos
(views), que le da forma al diseño de cada pantalla. Existe una activity por cada pantalla, por ende,
no se puede dividir en otras activities más pequeñas, de eso se encargan los fragments.
• Fragments: Un fragment es una porción de la interfaz. Una activity no se puede dividir en
activities más pequeñas, para eso existen los fragments, es por ello que una activity, puede estar
compuesta por uno o varios fragments.
• view: Una view es todo aquel elemento gráfico que compone una activity. Son los componentes
con los que se edifica la interfaz gráfica, estos pueden ser: botones, imágenes, cuadros de
texto…entre otros y, como es lógico tendrán el diseño que el programador desee.
• Service: Componentes que se ejecutan en segundo plano y no cuentan con una interfaz. Pueden
ejecutar acciones como detener una reproducción, actualizar datos, lanzar notificaciones o
mostrar elementos.
• Broadcast Receivers: Componentes que responden a avisos y anuncios de difusión. Los avisos
pueden provenir del sistema o de otras aplicaciones, ejemplo de los provenientes del sistema, es
5
una llamada o mensaje entrante, baja batería…entre otros, los cuales se activan a través de
mensajes asincrónicos llamados intents.
• Intent: Elemento de comunicación entre los distintos componentes de Android, se puede decir
que son los mensajes que se envían los diferentes componentes de una aplicación o entre distintas
aplicaciones. Mediante un intent se puede mostrar una actividad desde cualquier otra, iniciar un
servicio, enviar un mensaje broadcast, iniciar otra aplicación, entre otras acciones.
• Lenguaje xml: El lenguaje “xml” es muy útil para realizar programaciones estáticamente. Los
elementos “xml” se componen de una etiqueta de apertura con el nombre de la view, antecedido
del signo “menor que”, por ejemplo: “<TextView” y de una etiqueta de cierre “/>”.
• Navigation Editor: Es la herramienta que permite realizar conexiones entre las activities sin tener
que programar.
• Style: Un style, es un conjunto de propiedades, que definen el aspecto y forma de un elemento
determinado dentro de la aplicación.
• Palette’s Layouts: Los Layouts de la sección Palette dentro del Editor Visual, extienden a la clase
base ViewGroup, por tanto, son componentes contenedores de views. Los Layouts son elementos
no visuales, que contribuyen al ordenamiento y distribución de las views en la interfaz gráfica.
• Widgets: Son elementos visuales, que pueden ser estáticos o interactivos, por ende, al mostrarse
en la pantalla principal del dispositivo Android, pueden contener datos actualizables o responder
a métodos. Los controles más usados son los textos, los botones en sus distintas modalidades, las
imágenes y las diferentes barras de progresión.
• Text Fields: Los Text Fields son los encargados de la introducción y edición de textos, por parte
del usuario y pueden ser de tipo: Plain Text, Person Name, Password, E-mail, Phone, Time, Date,
Number…entre otros. Son empleados, frecuentemente, para que el usuario introduzca el valor de
las incógnitas, en los ejercicios a resolver. Es habitual que estén acompañados de un hint o pista,
para que el usuario tenga certeza del contenido que debe insertar en el componente.
• Containers: Son componentes que agrupan y ordenan una serie de elementos dentro de la
interfaz.
• Componente Tree: Establece una jerarquía en forma de árbol, dando prioridad a los componentes
que se encuentren encima. Si una view se encuentra encima de otra, se entiende que, la que está
arriba, es la primera que fue insertada y la de abajo, la última. Por esta razón, los componentes
que se encuentran debajo se superponen a los que están encima.
6
1.2CREACIÓN DE UN NUEVO PROYECTO Y DE UNA ACTIVITY
En la primera ocasión que se abre Android Studio, aparecerá la siguiente ventana principal, donde
se debe elegir “Start a new Android Studio project”:
Figura 2: Ventana principal en la inicialización de Android Studio.
Posteriormente, aparece la ventana de configuración del proyecto. En el primer diálogo se

introduce el nombre de la aplicación, en el segundo, la procedencia de la empresa que crea la
aplicación, que será el nombre del paquete que asigna Java para los archivos fuentes; mientras que,
el tercer diálogo corresponde a la localización del nuevo proyecto, como se muestra a continuación:
7
Figura 3: Ventana de configuración del proyecto.
En la siguiente ventana se especifican el tipo de dispositivo para el cual se programará y la menor

versión android para la cual se ejecutará la aplicación. Se puede dejar la que viene por defecto, como
se muestra en la siguiente imagen o se puede realizar un estudio de mercado, pues las versiones
actuales cambian con mucha frecuencia.
Debe destacarse que, existen tres tipos de denominaciones para la versión android. La comercial
se refiere al nombre de un postre, por ejemplo: Ice Cream Sandwich. La designación que empleada
por los fabricantes hace referencia a la versión y subversión, como es la 4.0.3. Por otro lado, la
calificación de los desarrolladores hace uso del nivel del API, como es la API 15.
Figura 4: Ventana de selección de tipo de dispositivo y de versión android.
8
En la siguiente ventana se escoge la plantilla de activity con la cual se iniciará el proyecto. Si se

elige “Blank Activity”, se configura manualmente la interfaz gráfica de la aplicación.
Figura 5: Ventana de selección de tipo de activity inicial.
Consecutivamente, se pueden nombrar los diferentes aspectos de la activity. Generalmente se

renombran las activities para diferenciarlas en caso de tener varias en el proyecto.
Figura 6: Ventana de opciones de la activity.
A continuación, se observa, luego de estas configuraciones iniciales, el entorno de Android Studio,

que brinda una herramienta poderosa con la cual se pueden realizar proyectos impresionantes.
9
Figura 7: Entorno Android Studio.
1. Main Menu Bar: La barra de menú principal permite abrir, crear proyectos, depurar aplicaciones...
2. Toolbar: La barra de herramientas contiene acciones de administración de archivos como abrir,
copiar, pegar, cortar, deshacer, emular y depurar aplicaciones…
3. Navigation Bar: Mediante la barra de navegación, se puede observar la ruta de un fichero
determinado.
4. Editor Tabs: Las pestañas del editor muestran los archivos, tanto “.java” como “xml” de uso
reciente e indican el archivo con el que se está trabajando.
5. Tool Buttons: Los botones de herramientas permiten acceder a las ventanas de herramientas y su
posición puede ser modificada, para mayor comodidad del programador.
6. Project Tool Window: La ventana de herramientas del proyecto muestra el alcance global de
todos los archivos y carpetas del proyecto.
7. Editor Window: El editor de código muestra la interfaz gráfica de la aplicación. Será
profundizado más adelante.
8. Marker Bar: La barra de alertas indica las líneas de código que deben tener un cuidado especial.
Generalmente, indica errores o warnings, de esta forma, si selecciona encima de un segmento
horizontal, este indicará hacia la línea en alusión.
9. Status Bar: La barra de estado muestra información sobre el estado del compilador, notificaciones
de errores…
10
1.3CREACIÓN DE UN ANDROID VIRTUAL DEVICE (AVD)
Un paso natural en la creación de aplicaciones, consiste en probar las mismas en dispositivos

virtuales, antes de lanzarlas a dispositivos reales. El “SDK” de Android Studio ofrece la posibilidad
de realizar estas pruebas sin la necesidad de un teléfono real. Es necesario definir un Android Virtual
Device (AVD), que no es más que un dispositivo que emula un terminal con android instalado.
Creación de un AVD:
1. Abrir el “AVD Manager”, que es la herramienta que permite crear las máquinas virtuales dentro
del equipo.
Figura 8: Ubicación del AVD Manager.
2. Crear un ADV, seleccionando el botón “Create a virtual device”.
Figura 9: Creación de una máquina virtual.
3. Elegir el tipo de equipo que se desea emular, atendiendo a su resolución, en una lista de
dispositivos que contiene Android Studio. Se debe tener en cuenta que, a mayor resolución del
dispositivo, requerirá mayor memoria dentro del sistema, por eso se recomienda que, si se cuenta
con una computadora de bajas prestaciones, se elijan dispositivos de menor resolución.
11
Figura 10: Selección del tipo de dispositivo virtual.
4. Seleccionar el nivel de API de la aplicación, que no es más que la versión android mínima para
la cual se va a desarrollar la aplicación celular.
Figura 11: Selección de la versión android de la máquina virtual.
La versión de android es muy importante dentro de la configuración de la máquina virtual, por eso
se debe comprobar las versiones android que se tienen instaladas en Android Studio. En el “SDK
Manager” se pueden controlar aquellas versiones de android a las cuáles se les quiere dar soporte
dentro de la aplicación. Las versiones que se tengan instaladas permiten la generación de máquinas
virtuales, para ello se instala el SDK y las imágenes del sistema. En la siguiente figura se muestra su
ubicación:
12
Figura 12: Ubicación del SDK Manager.
5. Comprobar la configuración del dispositivo virtual y se le puede asignar un nombre.
Figura 13: Configuración de la máquina virtual.
6. Una vez que se ha configurado el AVD, se muestra una lista con los dispositivos virtuales creados
dentro de Android Studio. Esto permite probar los proyectos en varios terminales y detectar
errores antes de instalarlos en los móviles reales. Cada uno cuenta con un desplegable con varias
opciones como se muestra a continuación:
Figura 14: Lista de máquinas virtuales instaladas en Android Studio.
7. Para finalizar, se selecciona “OK” y ya se tiene el AVD creado y configurado.
13
1.3.1 EMULACIÓN Y DEPURACIÓN DEL PROYECTO
Emulación de la aplicación mediante una máquina virtual:

1. Emular la aplicación seleccionando la opción “Run app”, como se muestra a continuación:
Figura 15: Ubicación del emulador de aplicaciones.
2. Seleccionar el dispositivo virtual en el cual se ejecutará la aplicación. Se cuenta con varias

opciones: la primera consiste en seleccionar un dispositivo que ya se esté emulando; mientras que
la segunda opción permite lanzar un emulador desde el inicio y escoger cuál se desea o incluso
crear uno nuevo.
Figura 16: Selección de la máquina virtual para emular la aplicación.
3. Luego Android Studio compila la aplicación y va a convertir todo el código en una aplicación
que se pueda ejecutar dentro de android, como se muestra en la siguiente figura:
14
Figura 17: Ejemplo de un dispositivo virtual para emular una aplicación.
Depuración de la aplicación mediante la herramienta LogCat:

Una vez que se ha terminado la aplicación, se debe depurarla. La herramienta destinada a esta
labor es “LogCat” y permite encontrar cualquier error y darle solución de manera rápida. La función
del LogCat no es detectar errores dentro del código de programación, pues para eso, está el propio
Android Studio; más bien esta herramienta muestra errores que se producen únicamente cuando la
aplicación se está ejecutando. Esta herramienta estará conectada con la aplicación por medio del
emulador, por ende, se debe tener una máquina virtual funcionando para que se pueda emplear.
Los pasos siguientes abordan la depuración y son evidenciados en la figura que les sucede,
específicamente en las zonas destacadas en azul:
1. Seleccionar la pestaña Android.
2. Comprobar que el emulador esté conectado a la aplicación.
3. Seleccionar en el desplegable de “Log level” la opción “Info”.
4. Analizar la información que muestra el área destinada para la señalización de los eventos en el
LogCat.
Figura 18: Depuración mediante la herramienta LogCat.
15
1.4CARPETAS Y SUBCARPETAS DEL SISTEMA
Dentro de todo proyecto, la organización y el control de los archivos es fundamental para que la
idea concebida, sea llevada a cabo. Por esta razón, Android Studio contiene una serie de carpetas y
subcarpetas en las cuales se almacenan y distribuyen los archivos que componen la aplicación. A
continuación, se comentará sobre cada una de ellas.
1.4.1 CARPETAS DEL SISTEMA:
Dentro de la raíz “app”, existen 4 carpetas principales: manifests, java, res y assets, la cual no
viene por defecto, sino que hay que crearla. La ubicación de estas carpetas se muestra en la siguiente
imagen:
Figura 19: Carpetas del sistema.
➢ Carpeta manifests:
Esta carpeta almacena el archivo AndroidManifest.xml.
Archivo AndroidManifest.xml: Es el archivo, en lenguaje XML, en el que se almacena la
configuración de la aplicación, se insertan activities y se asignan permisos antes de la ejecución del
proyecto. El “Manifests” contiene información esencial como nombre, versión, ícono de la
apk…entre otros, pero a la vez contiene los componentes básicos de la aplicación, que el sistema
operativo se encarga de instanciar. Estos componentes son Activity, Services, Broadcast Receiver y
Content Provider.
• Activity: Entorno de la aplicación, es la combinación de los elementos gráficos, que le da forma

al diseño de cada pantalla. Existe una activity por cada pantalla, por ende, no se puede dividir en
otras activities más pequeñas, de eso se encargan los fragments.
16
• Service: Componentes que se ejecutan en segundo plano y no cuentan con una interfaz. Pueden
ejecutar acciones como detener una reproducción, actualizar datos, lanzar notificaciones o
mostrar elementos.
• Broadcast Receivers: Componentes que responden a avisos y anuncios de difusión. Los avisos
pueden provenir del sistema o de otras aplicaciones, ejemplo de los provenientes del sistema, es
una llamada o mensaje entrante, baja batería…entre otros, los cuales se activan a través de
mensajes asincrónicos llamados intents.
Intent: Elemento de comunicación entre los distintos componentes de Android, se puede decir que
son los mensajes que se envían los diferentes componentes de una aplicación o entre distintas
aplicaciones. Mediante un intent se puede mostrar una actividad desde cualquier otra, iniciar un
servicio, enviar un mensaje broadcast, iniciar otra aplicación, entre otras acciones.
• Content Provider: Componente que permite compartir información entre aplicaciones sin
mostrar detalles sobre su almacenamiento interno, su estructura, o su implementación. A través
de un content provider se puede dar acceso a cierta información almacenada en otra aplicación.
Esta es una herramienta muy utilizada en los dispositivos, ejemplo de sus aplicaciones son: el
calendario, los contactos, aplicaciones de envío de mensajes. Se pueden dividir en dos tipos: los
creados específicamente para una aplicación y el acceso a los que ya existen en otras aplicaciones
y brindan información.
➢ Carpeta java:
En esta carpeta se encuentra el archivo de extensión “.java”, en el que se concibe la programación
de cada activity. Este archivo contiene una serie de constantes con los ID de los recursos de la
aplicación, que están incluidos en la carpeta res. Se pueden almacenar, además, los distintos métodos
a emplear en cada activity, así como el orden de la pantalla inmediata superior e inferior.
➢ Carpeta res:
Carpeta donde se almacenan lo recursos (resources) de la aplicación, tales como audios, imágenes,
videos, los textos en uno o varios idiomas, dimensiones, estilos, colores, animaciones...entre otros.
Los ficheros de recurso deben estar en minúscula y sin espacios o unidos mediante el guion bajo (_),
debido a que, estos ficheros van a ser llamados desde el archivo “.java” y convertidos en variables.
No se puede poner cualquier nombre a las carpetas dentro de “res”, más bien estas deben poseer una
17
estructura específica. La estructura interna de esta carpeta es: animator, anim, color, drawable, layout,
menú, raw, values y xml, las cuales serán explicadas en el apartado que trate las subcarpetas de res.
➢ Carpeta assets:
Carpeta en la que se pueden alojar los demás ficheros auxiliares para el desarrollo de la aplicación,
como distintas fuentes de letras y archivos pequeños. La principal diferencia entre los archivos
almacenados en la subcarpeta raw y los que contiene la carpeta assets es que, para los segundos, no
se generarán un ID y se podrá acceder a ellos por su ruta como a cualquier otro fichero del sistema.
Admite archivos menores a 1 megabyte. No sale por defecto, sino que hay que crearla.
Creación de carpetas assets:

1. Se pulsa click derecho sobre la carpeta app.
2. Se escoge en el desplegable, la opción “New”, luego “Folder” y posteriormente “Assets folder”,
como se muestra en la siguiente figura:
Figura 20: Creación de la carpeta assets.
3. Para finalizar, se selecciona “OK”.
1.4.2 SUBCARPETAS DEL SISTEMA:
Las subcarpetas permiten diferenciar el lugar de almacenamiento de ficheros de categorías

similares. En la siguiente imagen, son mostradas algunas subcarpetas y, aunque no aparecen todas,
son una muestra de las más empleadas.
18
Figura 21: Muestra de las subcarpetas del sistema.
Subcarpeta de Java:
➢ com.example.company_domain.application_name: Se almacena el archivo “.java”.
Subcarpetas de Res:
➢ animator: Contiene archivos “.xml” con las propiedades de las animaciones. Mediante el
recurso “Property Animation” se definen las propiedades de una animación. Como las
veces que se tiene que repetir una animación, la duración... No sale por defecto, así que
hay que crearla de forma similar a la subcarpeta anim.
➢ anim: En esta subcarpeta se pueden colocar diferentes efectos destinados a objetos como
imágenes o botones. No viene por defecto, razón por la que hay que crearla. Mediante el
recurso “Tween Animation” se definen las interpolaciones de las animaciones como, por
ejemplo, si un objeto tiene que rotar, moverse…
Creación de la subcarpeta anim:

1. Se pulsa click derecho sobre la carpeta res.
2. Se escoge en el desplegable la opción “New”, luego “Folder” y posteriormente “Res Folder”.
3. Se cambia la ruta de localización de la carpeta y se sustituye con el nombre “anim” y después se
selecciona “OK”, como se muestra en la siguiente figura:
19
Figura 22: Creación de la subcarpeta anim.
4. Para finalizar se selecciona “OK” y se espera a que el compilador gradle termine de configurar
el proyecto.
➢ color: Contiene archivos “.xml” con la lista de colores en #RGB, #ARGB, #RRGGBB o
#AARRGGBB. Mediante el recurso “Color List”, se guarda toda la paleta de colores en
hexadecimal. No sale por defecto, sino que hay que crearla.
➢ drawable: Subcarpeta donde se almacenan las imágenes o archivos “.xml” que definen
imágenes. Toda imagen guardada dentro de esta subcarpeta, será optimizada y
comprimida, por lo que no permanecerá inalterada. De esta forma, si se pretende evitar
la optimización, se deben colocar las imágenes, dentro de la subcarpeta raw.
Para utilizar diferentes recursos, dependiendo de la resolución del dispositivo, se suele dividir en
las siguientes subcarpetas:
• mdpi: mediana resolución.
• hdpi: alta resolución.
• xhdpi: muy alta resolución.
• xxhdpi: extra alta resolución.
➢ layout: Subcarpeta que almacena los archivos “.xml” que contienen la interfaz visual de
cada pantalla.
20
Se puede, para una activity, tener varios layouts, en dependencia de la orientación del dispositivo.
Esto se logra pulsando el botón “Configuration to render this layout with inside the IDE”, como se
muestra en la siguiente figura:
Figura 23: Creación de una variación del layout al girar la pantalla.
Una vez que se realizaron los cambios deseados en el layout horizontal, se puede apreciar que la
activity contendrá 2 layouts, uno para cada orientación de la pantalla, como, por ejemplo:
“activity_main.xml” y “activity_main.xml (land)”
Nota: Esto no se debe confundir, con el botón que hace girar la pantalla, para mostrar una vista
previa de cómo quedaría al rotar la misma, pues al realizar esta acción, el layout no sufre ninguna
modificación. La ubicación de este botón, se muestra a continuación:
Figura 24: Opción que permite ver la interfaz cuando se gira la orientación del dispositivo.
➢ menu: Mediante el recurso “Menu” se almacenan elementos de los menús o de la barra

de acciones, como la ActionBar.
➢ raw: Subcarpeta en la que se pueden alojar audios y videos. Admite archivos mayores de
1 megabyte. No sale por defecto, sino que hay que crearla.
21
Creación de la subcarpeta raw:

1. Se pulsa click derecho sobre la carpeta res.
2. Se escoge en el desplegable, la opción “New” y luego “Android resource directory”.
3. Aparece una nueva ventana titulada “New resource directory” y, en ella, se pulsa despliega la
opción “Resource type” y se selecciona la opción “raw”, como se muestra en la siguiente figura:
Figura 25: Creación de la subcarpeta raw.
4. Para finalizar, se selecciona “OK”.
➢ values: Mediante el recurso “Values” se almacenan diferentes tipos de archivos de extensión

“.xml”, como styles, dimens, strings…
Los strings son empleados, fundamentalmente cuando se pretende que la aplicación tenga formato
en varios idiomas. Por otro lado, los styles son muy empleados cuando se pretende lograr una
uniformidad, en las diferentes views, incluso activities, que componen la aplicación. De esta forma,
en vez de configurar cada view de un mismo tipo por separado, se crea un style y, a cada view, se le
asocia dicho style, lo cual ahorra muchísimo tiempo.
Cómo insertar un estilo y aplicarlo:

Un style, es un conjunto de propiedades, que definen el aspecto y forma de un elemento
determinado dentro de la aplicación. Se recomienda separar los styles de los layout, debido a las
ventajas que esto trae consigo, como tener diferentes styles, según sea el tipo de dispositivo o el
tamaño de la pantalla. Producto del amplio uso que tienen los styles, a continuación, se explica cómo
crear uno y cómo aplicarlo a los demás elementos, dentro de una misma categoría.
22
1. Insertar una view y asignarle las propiedades que se desean que tengan los demás elementos.
2. Seleccionar la pestaña “Text” y copiar la línea de código referente a la view creada.
Figura 26: Línea de código referida a la view del cual se quiere reproducir el style.
3. Abrir el archivo “styles-xml”, ubicado en la subcarpeta “values”, dentro de la carpeta “res” y

pegar la línea de código copiada.
Figura 27: Ubicación del archivo ".xml" que contiene los diferentes styles guardados.
4. Modificar la línea de código para que el estilo pueda ser aplicado y asignarle nombre. Se debe
prestar atención al formato requerido, en especial a los signos (") y (>), además de eliminar
aquellas líneas de código que no se desea que se repitan. Estas líneas son aquellas referidas al
nombre de la view, a la ubicación de la misma dentro del layout, al texto que en él aparece...entre
otros, como, por ejemplo, “android:id="@+id/button2"”.
23
Figura 28: Ejemplo de cómo crear y modificar un style.
5. Regresar a la pestaña “Desing” e insertar una nueva view.

6. Seleccionar la opción “style” dentro de la pestaña “Properties” y asignarle a la nueva view el
estilo creado.
Figura 29: Ubicación de los styles guardados para aplicarlos a una view.
➢ Xml: Mediante el recurso “AppWidget Provider”, se almacenan las propiedades de las

AppWidget, tales como el tiempo de actualizado, el diseño que tendrá… Mediante el
24
recurso “Preference” se pueden crear activities (PreferenceActivity) de preferencias de

usuario. Mediante el recurso “Searchable” se puede activar el autocompletar en los
campos de búsqueda.
Subcarpetas de assets:
➢ font: En estas subcarpetas se pueden alojar fuentes de letras. No sale por defecto, sino
que hay que crearla.
Creación de la subcarpeta font:

1. Pulsar click derecho sobre la carpeta assets.
2. Seleccionar en el desplegable la opción “New” y luego “Directory”, como se muestra en la
siguiente figura:
Figura 30: Creación de la subcarpeta font.
3. Introducir el nombre de la subcarpeta “font”:
Nota: Cómo aplicarle a un campo de texto, un tipo de fuente determinado, se explicará más
adelante, en el apartado 1.8.2.
25
1.5INTERFAZ DE USUARIO Y ARCHIVOS .XML
Como se ha explicado anteriormente, el entorno gráfico para diseñar la interfaz de usuario, se

encuentra en la subcarpeta layout dentro de la carpeta res. En esta ruta, se localiza el archivo
“activity_main.xml” que almacena las características visuales del layout, por ende, existen tantos
archivos “.xml”, como pantallas en el proyecto. Este archivo permite visualizar la interfaz en forma
de diseño (Desing) o en forma de código (Text).
Nota: Se han empleado algunos términos anteriormente, pero es en este acápite, en el que se
considera oportuno definirlos, para lograr una mayor comprensión de los componentes de la interfaz
gráfica.
El layout es el diseño que define la estructura visual del proyecto, es el ambiente de programación
donde se generará la interfaz gráfica de la aplicación, relacionando las diferentes activities. La mejor
manera de declarar este diseño es estáticamente, en la subcarpeta layout, porque consume menos
recursos, al tardar menos en procesarse y, además, se pueden encontrar más fácilmente los errores,
pudiéndose observar el resultado en tiempo real.
Una activity, como ya se ha explicado es el entorno de la aplicación, es la combinación de las
views y no se puede dividir en otras activities más pequeñas, de eso se encargan los fragments.
Un fragment es una porción de la interfaz. Una activity no se puede dividir en activities más
pequeñas, para eso existen los fragments, es por ello que una activity, puede estar compuesta por uno
o varios fragments. El motivo de creación de esta división de interfaces, fue para que una misma
aplicación pudiera ser multi-pantalla. Por este motivo, su mayor virtud es la reutilización de código.
Los fragments se colocan siempre sobre una activity, la cual se denomina “activity contenedora” de
fragments. El ciclo de vida de los mismos, está condicionado por la ejecución de su activity
contenedora, en la cual este debe ser declarado.
Una view es todo aquel elemento gráfico que compone una activity. Son los componentes con los
que se edifica la interfaz gráfica, estos pueden ser: botones, imágenes, cuadros de texto…entre otros
y, como es lógico tendrán el diseño que el programador desee. Las diferentes views se disponen en
forma de árbol, cuya raíz es el fichero “activity_main.xml”, que se encuentra en la subcarpeta layout.
Pueden ser individuales (TextView, EditText, ProgressBar, ImageView, Button, CheckBox…) o
grupales (LinearLayout, FrameLayout).
A continuación, se explican las secciones del editor de diseños gráficos, al cual se puede acceder,
haciendo doble click en el archivo “activity_main.xml”, que se encuentra en la subcarpeta layout
dentro de la carpeta res:
26
Figura 31: Secciones del editor de diseño gráfico.
1. Palette: Donde se encuentran las views, las cuales se pueden arrastrar al Editor o al Component Tree.
2. Configuration Chooser: Barra en la que se localizan diferentes configuraciones de pantalla y de
renderizado para las views insertadas. Ejemplo de estas opciones son: rotar la pantalla, creación de
un layout diferente al rotar la pantalla, insertar otro idioma para darle soporte a la aplicación…
3. Component Tree: Esta sección establece la jerarquía en árbol de las views, dando prioridad a las que
se encuentren encima. Es muy usada cuando se quiere tener certeza de la selección de una view en
específico, para asignarle sus propiedades.
4. Editor visual: Es muy útil, pues muestra en tiempo real el diseño de la activity en uno, o incluso, en
varios dispositivos, simultáneamente. Establece, por tanto, una clara idea de las dimensiones y
márgenes que las views deben poseer.
5. Properties: Propiedades de la view seleccionada o layout. En esta sección se puede editar el texto, el
color, tamaño, asociarles pistas para que el usuario sepa lo que debe rellenar…entre otras propiedades,
que serán detalladas posteriormente.
6. Pestañas para cambiar entre el “Editor gráfico” y el “código xml” que se genera. A pesar que el
Android Studio presenta un entorno muy amigable, pues se pueden insertar botones, imágenes… sin
tener que programar, existen cuestiones que se les escapa, es por esto que se recomienda, en muchos
casos, comprobar el diseño mediante el código “xml”, en la pestaña “Text”.
El lenguaje “xml” es muy útil para realizar programaciones estáticamente. Los elementos “xml”
se componen de una etiqueta de apertura con el nombre de la view, antecedido del signo “menor que”,
por ejemplo: “<TextView” y de una etiqueta de cierre “/>”. Contendrán, entre estas etiquetas,
27
atributos opcionales, que se iniciarán con la palabra “android” seguida del signo “dos puntos”. Luego
le continuará la propiedad a la que se hace alusión, como por ejemplo “textColor”, seguida del signo
“igual” y, finalmente, el valor de la propiedad entre comillas. Un ejemplo de una línea de código, que
hace referencia a una propiedad es: android:textColor="#ffffffff". Aunque el Editor gráfico ofrece
muchas ventajas, desde el punto de vista de la sencillez para insertar views y asignarle propiedades,
incluso en cuanto al tiempo de programación, lo cierto es que el código “xml”, no debe ser visto como
una herramienta opcional, sino como el principal mecanismo de diseño gráfico y de detección de
errores.
1.5.1 PALETTE
En esta sección, como se ha indicado, se encuentran las views y estas pueden ser arrastradas tanto,
al Editor como al Component Tree. Se debe seleccionar entre sus 7 carpetas, cuál es el tipo de view
que se desea insertar. Las carpetas pertenecientes a la Palette son: Layouts, Widgets, Text Fields,
Containers, Date & Time, Expert y Custom. A continuación, se muestra la ubicación de esta sección
y más adelante, se abordan las más usadas:
Figura 32: Pestaña Palette.
1.5.1.1 LAYOUTS
Los Layouts de la sección Palette dentro del Editor Visual, extienden a la clase base ViewGroup,
por tanto, son componentes contenedores de views. Los Layouts son elementos no visuales, que
contribuyen al ordenamiento y distribución de las views en la interfaz gráfica. En la siguiente imagen,
se muestran los diferentes tipos de componentes contenedores de otros componentes:
28
Figura 33: Carpeta Layouts de la pestaña Palette.
El FrameLayout coloca todos sus controles asociados, alineados en su esquina superior izquierda,
de forma que, cada componente quedará oculto por el siguiente, exceptuando los casos, en los que el
último control presente transparencia. Es un componente contenedor sencillo y muy usado en el
empleo de imágenes.
Existen dos tipos de LinearLayout, el horizontal y el vertical, los cuales organizan sus
componentes asociados en filas o columnas, respectivamente. Además, crea una barra de Scroll si la
longitud es superior al tamaño de la pantalla.
El TableLayout permite distribuir sus componentes de forma tabular, definiendo las filas y
columnas necesarias y la posición de cada componente dentro de la tabla. La estructura de la tabla se
define indicando las filas que compondrán la tabla y dentro de cada fila las columnas necesarias,
insertando directamente los controles necesarios dentro del TableRow, los cuales pueden ser una view
o incluso una ViewGroup. El número final de filas de la tabla se corresponderá con el número de
elementos TableRow insertados, mientras que, el número total de columnas quedará determinado por
el número de componentes de la fila que más componentes contenga.
El GridLayout organiza sus componentes asociados en una cuadrícula.
Un RelativeLayout especifica la colocación de sus componentes, en relación a la ubicación de los
otros componentes asociados o respecto a sus bordes.
Nota: En el apartado de los Containers, se explicará qué es y cómo se emplea el componente
Scroll View. Se considera oportuno aclarar en esta instancia, que el mismo tiene la característica de
admitir un solo elemento, por ello, se recomienda que, todos los views se inserten dentro de un
RelativeLayout, para que luego este RelativeLayout, sea introducido en el ScrollView y mantener fijas
las dimensiones y distribución de los elementos, sin importar el tamaño de la pantalla o el tipo de
dispositivo en el que se ejecute la aplicación.
29
1.5.1.2 WIDGETS
Los Widgets son elementos visuales, que pueden ser estáticos o interactivos, por ende, al mostrarse
en la pantalla principal del dispositivo Android, pueden contener datos actualizables o responder a
métodos. Los controles más usados son los textos, los botones en sus distintas modalidades, las
imágenes y las diferentes barras de progresión. A continuación, se muestran los distintos tipos de
componentes de esta categoría y se explican los más usados:
Figura 34: Carpeta Widgets de la pestaña Palette.
Los componentes de tipo TextView son: Plain TextView, Large Text, Medium Text y Small Text,
los cuales son escogidos, de acuerdo al tamaño del texto que se desea insertar y, como su nombre
indica, son etiquetas para mostrar determinados textos al usuario. Estos controles son estáticos,
cuando no cambian su contenido durante el ciclo de vida de la activity en la que se encuentran. Son
textos fijos y son muy usados como encabezados de los ejercicios o como nombre de los datos, que
el usuario deberá insertar. Por otro lado, son calificados como interactivos, cuando cambian su
contenido en dependencia de determinadas situaciones. Un ejemplo del uso de textos interactivos es
la respuesta de determinado problema, al que se le da solución.
Nota: Es importante destacar que, si un componente de texto (Text) de tipo Widgets, es empleado
en la interfaz, el tipo de variable, en la programación Java, que se le debe asociar, es de tipo TextView.
30
Android Studio brinda la opción de seleccionar, una opción dentro de una lista de posibilidades.
Existen varios tipos de controles para realizar esta acción: listas desplegables (Spinner), listas fijas
(LisView) y tablas (GridView), incluso controles específicos, como las galerías de imágenes (Gallery).
Las ListView, GridView y Gallery, se encuentran en la carpeta Containers. Una característica común
en los controles de selección es el uso de los adaptadores (adapters), que son el elemento mediante
el cual, los controles de selección, acceden a los datos que contienen y serán explicados más adelante,
cuando se profundice en el empleo del control de tipo Spinner.
En android, las listas desplegables son denominadas Spinner. El accionar de este control, consiste
en la selección de un ítem por parte del usuario y el despliegue, en consecuencia, de una lista con las
opciones disponibles. De tal forma que, al seleccionar una de ellas, dicha opción queda fija en el
control. Cómo se emplean las mismas, será explicado más adelante.
Un RadioButton es un control que puede estar marcado o no y suele utilizarse dentro de un grupo
de opciones, donde solamente puede estar marcada una de ellas, de forma que, si se marcara una
nueva opción, se desmarcará automáticamente, la que estuviese activa previamente. El evento
característico de este componente es “setChecked(true/false)”, el cual deberá ser repetido como
“false”, para desmarcar los demás buttons. Por ejemplo, si existen tres RadioButtons, dispuestos uno
a continuación de otro, en el archivo Java, se debe crear un método para cada uno de ellos. En cada
método, se introducen los tres RadioButtons, identificándolos mediante los recursos del sistema, con
el nombre (id) que fueron guardados previamente en la interfaz. A posteriori, si se hace referencia al
primer componente, se debe insertar “RadioButton_name.setChecked(true)”, para el primer control y
se debe repetir “RadioButton_name.setChecked(false)”, por cada button restante. De esta manera, al
seleccionar el primero, se deseleccionan los demás.
Un CheckBox suele ser empleado para marcar o desmarcar una o varias opciones y está
representado por la clase del mismo nombre, CheckBox. La manera de definirlo en la interfaz y los
métodos disponibles para su empleo, son similares a los del componente ToggleButton.
La ImageView es un contenedor de imágenes y para asociarle una figura, similar al ImageButton,
se debe efectuar a través de la opción src en la sección Properties.
La ProgressBar y la SeekBar son muy similares. Una vez insertada alguna de estas componentes,
se debe especificar, en la interfaz, el máximo valor (max) y el intervalo (progress) que tendrá;
mientras que, en el archivo Java, se emplea el método “SeekBar_name.getProgress()”.
El componente Button, puede ser de tres tipos: el clásico (Button y SmallButton), el ToggleButton
y el que puede contener una imagen (ImageButton). El primero es el botón más básico que se puede
emplear, el segundo, es un tipo de botón que puede permanecer en dos estados: pulsado o no pulsado;
mientras que, mediante el tercero, se puede definir una imagen a mostrar, en vez de un texto, mediante
31
la opción src, que se encuentra ubicada en la sección Properties. Se debe especificar que, esta imagen,
debe estar guardada previamente en la subcarpeta drawable dentro de la carpeta res.
Métodos asociados a un button

Si se desea que, al pulsar el button, se ejecute una acción determinada, se debe crear un método
público en el archivo Java y, en la opción onClick de la sección Properties, asociarlo al button. A
pesar que, en esta instancia, no se ha abordado lo referente al lenguaje Java, se considera oportuno
destacar que, para capturar el pulsado del button, se debe implementar el método
setOnClickListener(); mientras que, en el caso del ToggleButton, suele emplearse el método
isChecked().
1.5.1.3 TEXT FIELDS
Los Text Fields son los encargados de la introducción y edición de textos, por parte del usuario y
pueden ser de tipo: Plain Text, Person Name, Password, E-mail, Phone, Time, Date, Number…entre
otros. Son empleados, frecuentemente, para que el usuario introduzca el valor de las incógnitas, en
los ejercicios a resolver. Es habitual que estén acompañados de un hint o pista, para que el usuario
tenga certeza del contenido que debe insertar en el componente.
Los componentes del tipo Text Fields en la inetrfaz, son asociados a las variables de tipo EditText,
en el archivo Java. Los casos de mayor interés son los textos y los números y ambos tienen en común,
que deben ser convertidos en cadenas de caracteres (Strings), para poder ejecutar acciones con ellos.
Si son insertados textos, como son Plain Text o Person Name, estos se convierten directamente en
EditText, encontrándolos por sus respectivos id, mediante los recursos del sistema y, posteriormente,
se convierten en Strings, para ser usados en operaciones.
Si, por el contrario, se insertan números, como es el caso de Number o Number (Decimal), en
dependencia si es un número entero o decimal, se deben declarar tantas operaciones como variables
de tipo number existan. Luego se convierten en EditText, encontrándolas por sus respectivos id,
mediante los recursos del sistema y, posteriormente, se convierten en Strings. En dependencia de la
cantidad de cifras decimales, pueden ser: int, double, float…
En la siguiente figura, se muestra la ubicación de los Text Fields.
32
Figura 35: Carpeta Text Fields de la pestaña Palette.
1.5.1.4 CONTAINERS
Los Containers son componentes que agrupan y ordenan una serie de elementos dentro de la
interfaz. Su ubicación se muestra en la siguiente imagen:
Figura 36: Carpeta Containers de la pestaña Palette.
33
El RadioGroup es un controlador que permite agrupar un conjunto de RadioButtons, donde sólo

uno puede estar seleccionado a la vez.
Un componente ListView muestra una lista de opciones seleccionables, pero sin una lista
desplegable, como el control Spinner. Si existiesen más opciones que las que el tamaño de la pantalla
permita mostrar, se deberá insertar un scroll, en el cual se almacenará dicha lista, para poder acceder
a todos los elementos.
El control GridView es menos empleado que el Spinner o la ListView. Exhibe una serie de
elementos seleccionables distribuidos de forma tabular. Entre las opciones que deben ser resaltadas
en este tipo de controles se encuentran: el número de columnas (android:numColumns), el ancho de
las columnas (android:columnWidth), el espacio horizontal (android:horizontalSpacing) y vertical
(android:verticalSpacing) entre las celdas…entre otros.
El ScrollView y el HorizontalScrollView son empleados para acceder a elementos que, por el
tamaño de la pantalla, no se alcanzan en la vertical u horizontal, respectivamente. Una cuestión
importante en el empleo de estos componentes es que sólo admiten un elemento dentro de ellos, por
ende, son asociados a ListView o a RelativeLayout, como ya se explicó anteriormente.
El VideoView es el componente que es empleado para la reproducción de videos. Posteriormente,
en otro apartado, se profundizará en su aplicación.
1.5.2 COMPONENT TREE
Establece una jerarquía en forma de árbol, dando prioridad a los componentes que se encuentren
encima. Si una view se encuentra encima de otra, se entiende que, la que está arriba, es la primera que
fue insertada y la de abajo, la última. Por esta razón, los componentes que se encuentran debajo, se
superponen a los que están encima. Por ejemplo, de los componentes dentro de un FrameLayout, el
que se encuentra en el extremo inferior, es el que se ve por encima de los demás, porque fue el último
que se introdujo.
Figura 37: Pestaña Component Tree.
34
1.5.3 PROPERTIES
Esta sección es la que impone las diversas propiedades a los elementos de la interfaz, incluyendo
a los contenedores de las views. Las propiedades pueden estar referidas al margen, ubicación, nombre,
color, tamaño…entre otras. Sin embargo, la lista de propiedades en esta sección depende de la view
que se encuentre seleccionada, de esta forma, la pestaña cambia en dependencia si el componente es
una ImageView o un Button. En la siguiente imagen se muestra su localización y, posteriormente, se
explican algunas de estas opciones.
Figura 38: Pestaña Properties.
• layout width: Hace referencia al ancho de la view y puede ser variable o fijo. Los valores variables
son las opciones que ofrece: “fill_parent” (para que el componente adopte la dimensión de la
pantalla a todo lo ancho) o “wrap_content” (para que el componente adopte la dimensión de su
contenido, independientemente del ancho de la pantalla). Por otro lado, los valores fijos tienen la
unidad de medida “dp”, por ejemplo, 150dp.
• layout height: Hace referencia a la altura de la view y puede ser variable o fijo, de forma similar
al layout width.
• layout margin: Contiene 5 opciones: all, left, top, right, bottom y se refieren a la distancia (en
dp) de cada margen.
• layout:alignComponent: Se refiere al distanciamiento respecto a otro componente. Es muy usado
cuando las views se encuentran en un RelativeLayout.
• style: Permite asociarle a una view, un style determinado en la lista de estilos, para lograr
uniformidad en el diseño, tal como se explicó anteriormente.
• alpha: Establece transparencia a botones, imágenes…mediante un rango de valores entre 0 y 1,
considerando que 0 es totalmente opaco y 1 es totalmente trasparente. Esto no se debe confundir
35
con la transparencia (opacity) que se le puede dar a un fondo o texto, mediante las dos primeras
letras del código de colores en #AARRGGBB.
• background: Permite cambiar el fondo de un button, activity… ya sea mediante la escala de
colores en #AARRGGBB o una imagen, previamente almacenada en la subcarpeta drawable
dentro de la carpeta res.
• hint: Ofrece una pista de lo que el usuario debe escribir. A menudo esta propiedad es muy usada
en los Text Fields.
• id: Asigna un nombre distintivo a la view para localizarla en el archivo Java o en el layout.
• onClick: Permite asociarle un evento a un button, RadioButton, ImageButton…previamente
concebido en el archivo Java.
• text: Establece el texto que se va a mostrar. Es muy empleado en controles como button,
textView…
• textColor: Establece, como su nombre lo indica, el color del texto mediante la escala de colores
en #AARRGGBB.
• textSize: Establece el tamaño del texto mediante la unidad de medida “sp”, por ejemplo, 15sp.
• textStyle: Ofrece tres opciones: normal, bold e italic. Refiriéndose las dos últimas al estilo de
texto negrita y cursiva, respectivamente.
src: Permite asociarle una imagen al componente ImageView o ImageButton.
1.6INSERCIÓN DE DISTINTOS TIPOS DE ARCHIVOS
Los archivos son una componente importante dentro de las aplicaciones, pues le otorgan efectos
que resultan atractivos para el usuario, por ende, es importante conocer la forma de insertarlos en los
proyectos. Antes de explicar esta técnica, se detallarán dos cuestiones que se consideran de suma
importancia, para alcanzar una mayor comprensión de estos temas: la captura del click en una view y
la diferencia entre declarar métodos, dentro del método Oncreate o fuera de él.
Captura del click de una view:

Capturar el click de una view, ya sea un button, una ImageView… puede ser, principalmente, de
tres maneras: declarando la view previamente e identificando el tipo de componente que sea (esto se
emplea cuando se requiere usar dicha view en otra acción); buscándola directamente en los recursos
de sistema o mediante la propiedad onClick, en la sección Properties.
36
A continuación, se aclaran los términos empleados y se muestran los dos primeros casos:
• TipoDeView: Se refiere al tipo de componente: Button, ImageView… (empleado en el caso 1).
• NombreDeLaView: Es el nombre, con el que va a ser identificado el componente contenedor del
método, para su posterior uso (empleado sólo en el caso 1).
• LocalizacionDeLaView: Se refiere a la ubicación de la view. Si se encuentra en la misma clase,
en la que se está programando, se inserta “this.”, si, por el contrario, se encuentra alojada en otra
variable (como puede ser el caso, de una variable contenedora de un layout), se inserta el nombre
de dicha variable, sucedida del signo “.” (punto).
• NombreDeLaViewEnElLayout: Se refiere al id que le fue asociado al componente en la interfaz.
Caso 1: Línea de código para capturar el click de una view declarándola previamente:
TipoDeView NombreDeLaView = (TipoDeView)
LocalizacionDeLaView.findViewById(R.id.NombreDeLaViewEnElLayout);
NombreDeLaView.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
//se inserta el método deseado
} });
Nota: En caso de emplearse esta primera situación, justo debajo de la declaración de la class, se
debe declarar, previamente, esta variable, de la siguiente forma: “private TipoDeView
NombreDeLaView”, por ejemplo: “private Button BCreado”.
Caso 2: Línea de código para capturar el click de una view sin declararla:
LocalizacionDeLaView.findViewById(R.id.NombreDeLaViewEnElLayout).setOnClickListene
r(new View.OnClickListener() {
@Override
} });
Diferencia entre declarar métodos, dentro del método Oncreate o fuera de él

Si los métodos son creados dentro del Oncreate, se ejecutarán al mismo tiempo que la activación
de la activity. Si, por el contrario, son creados, fuera de este, se ejecutarán, únicamente, cuando sean
llamados mediante una view, como ya se ha explicado.
37
Aclaradas estas cuestiones, se procede a describir la inclusión de imágenes, música y videos en

las activities.
1.6.1 INSERCIÓN DE IMÁGENES Y CAMBIO DEL ÍCONO
Como ya se ha explicado, las imágenes dentro de Android Studio son almacenadas en la

subcarpeta drawable dentro de la carpeta del sistema res y, en dependencia de la resolución de la
imagen, es ubicada en:
➢ xxhdpi: extra alta resolución.
➢ xhdpi: muy alta resolución.
➢ hdpi: alta resolución.
➢ mdpi: mediana resolución.
1.6.1.1 INSERTAR IMÁGENES EN LA APLICACIÓN:

1. Buscar en el equipo la imagen en el que se desea insertar, copiarla y pegarla en la subcarpeta
drawable específicamente en la resolución que se desee. Saldrá una ventana especificando el
nombre de la imagen y la ruta en la que será pegada, como se muestra en la Figura 39.
Posteriormente, en la Figura 40, se puede observar cómo queda insertada la imagen en la
subcarpeta con la resolución deseada.
Figura 39: Opciones de copiado de una imagen.
2. Insertar un contenedor o elemento gráfico de tipo ImageView, para que la imagen pueda ser
insertada dentro de la pantalla (o activity). Este contenedor de imagen está ubicado en la carpeta
Widgets que se encuentra en la pestaña Palette. Se puede observar cómo sale un cuadrado azul
pequeño, que es el contenedor, pero su tamaño se debe a que aún no tienen imagen asociada.
Todo esto se puede apreciar en la siguiente figura:
38
Figura 40: Inserción de un contenedor ImageView.
3. Seleccionar la opción src, que se encuentra ubicada en la pestaña Properties, como se muestra en
la Figura 40, esto se efectúa con el fin de asociarle la imagen al contenedor. Una vez abierta la
ventana “Resources”, se busca, en la carpeta “drawable” dentro de la pestaña “Project”, la imagen
por el nombre con el que fue guardada, como se muestra en la siguiente figura:
Figura 41: Selección de la imagen a insertar.
4. Realizar ajustes a la imagen en la pestaña “Properties”, como se muestra a continuación:
39
Figura 42: Ajustes a la imagen insertada.
1.6.1.2 CAMBIO DEL ÍCONO DE LA APLICACIÓN:
El ícono de la aplicación es fundamental para que los usuarios puedan distinguirla de resto de las
demás, por ende, debe ser original y atractivo.
Nota: Los pasos de 1 y 2 son sólo si el ícono que se desea insertar es una imagen.
1. Acceder, en el equipo, a la carpeta de recursos dentro de la carpeta del proyecto. La ubicación de
esta carpeta difiere en cada ordenador, pero se puede encontrar en la siguiente dirección:
C:\Users\User_Name\AndroidStudioProjects\Application_Name\app\src\main\res.
2. Una vez dentro de la carpeta “res” en la computadora, se encuentran varias carpetas. Las de interés
son 4 capetas con el nombre “drawable-image_resolution”. Se debe almacenar, en cada una de
estas carpetas, la imagen que se desea convertir en el ícono de la aplicación, con el nombre:
“ic_launcher”, en formato “.png” y sustituir el archivo que, en cada una de ellas, aparece por
defecto. Esta imagen debe tener el tamaño en píxeles que le corresponda a cada carpeta en la que
es guardada. Las resoluciones respectivas por carpeta son:
➢ drawable-mdpi: 48×48
➢ drawable-hdpi: 72×72
➢ drawable-xhdpi: 96×96
➢ drawable-xxhdpi: 144×144
3. Hacer click derecho en la carpeta “res”, luego se selecciona la opción “New” y después “Image
Asset”, como se muestra a continuación, para acceder a la ventana “Asset Studio”.
40
Figura 43: Ubicación de la herramienta “Image Asset” para cambiar el ícono.
4. Una vez que aparece la ventana “Asset Studio”, se puede administrar el ícono de la aplicación.
En esta ventana, se puede elegir el tipo de ícono, el cual puede ser una imagen (Image), una
imagen dentro del propio sistema operativo (Clipart) o un texto (Text). Si el ícono es una imagen,
en el diálogo “Image file”, se debe insertar la ubicación del archivo “ic_launcher”, que se
encuentra en la carpeta “drawable-xxhdpi”, resultante del paso 2. Todo lo anterior, se puede
observar a continuación:
Figura 44: Opciones para el cambio de ícono.
5. La última ventana del “Asset Studio” corresponde a una vista previa del nuevo ícono.
41
Figura 45: Vista preliminar del nuevo ícono.
1.6.2 INSERCIÓN Y REPRODUCCIÓN DE ARCHIVOS DE AUDIO
Los archivos de audio, como se explicó en el apartado de “Carpetas y subcarpetas del sistema”, se
encuentran, generalmente, en la subcarpeta raw, dentro de la carpeta res. El archivo de audio puede
ser reproducido inmediatamente que se ejecute la activity o mediante un botón, como se explicará a
continuación.
1.6.2.1 REPRODUCCIÓN DE AUDIOS AUTOMÁTICAMENTE CON LA

EJECUCIÓN DE LA ACTIVITY
1. Copiar el archivo de audio en la subcarpeta raw. Cuando se pegue el audio en la subcarpeta, se
mostrará la siguiente ventana, donde se debe comprobar el nombre del archivo y la ubicación del
mismo:
Figura 46: Ventana de comprobación de las características del archivo de audio.
42
Nota: Una vez copiado el audio, se puede comprobar su localización en la subcarpeta raw, dentro
de la carpeta res, como se muestra en la siguiente imagen:
Figura 47: Ubicación del archivo de audio en la subcarpeta raw.
2. Teclear la siguiente línea de código, justo donde indica la Figura 48. Estas líneas indican que se
creará una variable de tipo “MediaPlayer”, que se va a llamar “mp”. Dicha variable va a encontrar
un audio con el nombre “audio_name”, que se encuentra en la subcarpeta raw. Posteriormente se
inicia la reproducción de dicho audio que, al estar ubicado donde se muestra a continuación, se
inicia al mismo tiempo que la ejecución de la activity.
final MediaPlayer mp;

mp = MediaPlayer.create(this, R.raw.audio_name);
mp.start();
Figura 48: Ubicación de la línea de código para la inserción de un audio.
3. Como se ha explicado anteriormente, se deben corregir los errores en la programación, que indica
el Android Studio. En este caso se refiere a la necesidad de importar la class “MediaPlayer”, la
cual se puede importar presionando, simultáneamente, las teclas “Alt + Enter”.
43
1.6.2.2 EJECUCIÓN DE AUDIOS MEDIANTE BOTONES
Si, por el contrario, se quisiera reproducir el audio, pero a través de un botón, se almacena el audio
en la subcarpeta raw, como se explicó anteriormente y se inserta un button, al que se le asociará el
evento descrito en la siguiente línea de código:
Línea de código:
public void reproducir (View view) {
final MediaPlayer mp;
mp = MediaPlayer.create(this, R.raw.audio_name);
mp.start();
}
1.6.3 INSERCIÓN Y REPRODUCCIÓN DE VIDEOS

1. Copiar el archivo de video en la subcarpeta raw. Cuando se pegue el video en la subcarpeta, se
mostrará la siguiente ventana, donde se comprueba el nombre del archivo y la ubicación del
mismo.
Figura 49: Ventana de comprobación de las características del archivo de video.
2. Insertar, en la interfaz, un VideoView, ubicarlo en la posición deseada y asignarle un id para

identificarlo.
44
Figura 50: Ejemplo del uso de un VideoView.
3. Teclear la siguiente línea de código, justo donde indica la Figura 51. Es importante resaltar que,
el nombre que se introduce en el id de la variable “videoview”, es el de la view en la interfaz
(paso 2); además, en la ruta del archivo de la variable “path”, se debe insertar el nombre del
package y, por último, el nombre del video almacenado en la subcarpeta raw.
Línea de código:
VideoView videoView = (VideoView) findViewById(R.id.videoView);
Uri path = Uri.parse("android.resource://com.example.marlon5.myapplication/" + R.raw.video);
videoView.setVideoURI(path); videoView.start();
Nota: Si la línea de código es insertada justo donde se muestra en la siguiente imagen, la

reproducción se inicia al mismo tiempo que la ejecución de la activity. Si, por el contrario, se quisiera
reproducir el video, a través de un botón, se debe insertar un button, al que se le asociará un evento,
tal como se explicó para el caso de la reproducción de un audio mediante un botón.
Figura 51: Ubicación de la línea de código para la inserción de un video.
el Android Studio. En este caso se refiere a la necesidad de importar la class “VideoView” y la
“Uri”, las cuales se pueden importar presionando, simultáneamente, las teclas “Alt + Enter”.
45
1.7NAVEGACIÓN ENTRE ACTIVITIES
Una característica en la mayoría de las aplicaciones es la navegación entre pantallas mediante

elementos que realizan esta transportación. Siempre que la aplicación contenga más de una activity
y, por ende, más de una pantalla, son necesarios elementos como botones, imágenes, íconos…entre
otros, que funcionen como un puente entre las pantallas. Una consecuencia de la afirmación anterior
es la creación de una nueva activity, independientemente de la que se crea junto al proyecto.
Seguidamente, se explica cómo se crea una nueva activity y después, cómo se efectúa la navegación
entre pantallas.
1.7.1 CREACIÓN DE UNA NUEVA ACTIVITY
Si se pretende crear una nueva activity, es suficiente con pulsar click derecho en la carpeta res,
seleccionar la opción “New”, luego “Activity” y luego “Blank Activity”, como se muestra en la
siguiente imagen:
Figura 52: Creación de una nueva activity.
Luego se le asigna el nombre a la nueva activity, como se puede observar a continuación:
46
Figura 53: Asignación del nombre a la nueva activity.
Una vez que se ha asignado el nombre de la activity, esta se almacena en la carpeta “layout”, justo
debajo de la existente; por otro lado, se crea otro archivo “.java” que se guarda en la carpeta “java”,
como se muestra a continuación:
Figura 54: Ubicación en la nueva activity.
47
Por último, la creación de esta nueva activity, se puede constatar en el archivo “Android Manifest”,
que es modificado por esta acción, como se muestra en la Figura 55.
Figura 55: Modificación del archivo Android Manifest debido a una nueva activity.
1.7.2 NAVEGACIÓN ENTRE ACTIVITIES
La navegación entre activities, puede ser concebida de dos maneras: a través de una línea de código
de programación o mediante la herramienta Navigation Editor, sin necesidad de programar. A
continuación, se explican estos métodos:
Navegación mediante programación:

Línea de código para saltar a otra activity:
LocalizacionDeLaView.findViewById(R.id.
NombreDeLaViewEnElLayout).setOnClickListener(new View.OnClickListener() {
@Override
ActivityActual.this.startActivity(new Intent(ActivityActual.this,
PróximaActivity.class));
}
});
Nota: Los términos LocalizacionDeLaView y NombreDeLaViewEnElLayout, ya fueron
conceptualizados, mientras que, ActivityActual y PróximaActivity, se refieren, como sus nombres lo
indican, a la activity en la que se encuentra y a la activity a la que se pretende llegar, respectivamente.
48
Navegación mediante la herramienta Navigation Editor:

1. Seleccionar la herramienta “Navigation Editor” que permite realizar conexiones entre elementos
sin tener que programar. Su localización se muestra en la siguiente figura:
Figura 56: Ubicación de la herramienta de navegación entre pantallas Navigation Editor.
Nota: Una vez que se ha abierto el editor de navegación, de cada pantalla se muestra una flecha
apuntando a un rectángulo negro, que es donde deberían desplegarse los menús contextuales, si en la
aplicación no hay ninguno, sólo se muestra “settings”.
2. Establecer el orden de navegación y los elementos implicados. Para esta acción, se posiciona el
mouse encima del elemento de navegación, que puede ser un botón o una imagen, se presiona en
el teclado la tecla “Control” (Ctrl), se sostiene un click izquierdo y se arrastra hasta la otra pantalla
y se suelta. Una vez realizado esto, aparece una flecha desde el elemento seleccionado hasta la
pantalla que se pretende transitar, como se muestra en la siguiente figura:
Figura 57: Resultado del empleo del Navigation Editor.
49
1.8DIFERENTES TÉCNICAS DENTRO DE ANDROID STUDIO
A continuación, se abordarán diferentes temas que se consideran de importancia dentro de Android

Studio y que se recomiendan estudiar. Estas técnicas requieren de un dominio básico del lenguaje de
programación “Java”, pero, como son misceláneas, se decidió incluirlas en este acápite y analizar, de
esta forma, diferentes aspectos de la programación mediante este software.
1.8.1 BLOQUEO DE LA ORIENTACIÓN DE LA PANTALLA
En dependencia de lo que se proponga con una pantalla determinada, el programador determinará

si es conveniente o no que gire la pantalla cuando cambie la orientación del teléfono. Para bloquear
la orientación de la pantalla, es suficiente con teclear una de las siguientes líneas de código en el
archivo “.java” de una activity determinada:
❖ setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE); // (para que
esté siempre horizontal).
❖ setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT); // (para que
esté siempre vertical).
La línea de código debe ser escrita justo en la ubicación que se muestra en la siguiente imagen:
Figura 58: Ubicación de la línea de código para bloquear la orientación de la pantalla.
Como puede observarse, las letras en rojo indican un error en la programación que debe ser
corregido. En este caso se refiere a la necesidad de importar la class “ActivityInfo”. Esto puede ser
solucionado, situando el cursor del mouse justo encima del texto en rojo, presionar click izquierdo y
luego la combinación de las teclas “Alt + Enter” o, luego de efectuar el click izquierdo, presionar
“Crtl”, mover el cursor ligeramente hacia un lado, realizar un segundo click izquierdo y, con la tecla
50
“Crtl” presionada, desplazar el cursor hacia la izquierda, donde saldrá un bombillo rojo con un signo
exclamativo, como se muestra a continuación, el cual se debe seleccionar, para importar la class:
Figura 59: Alternativa para importar una class.
Una vez realizado cualquiera de los dos procedimientos para la importación de la class, las letras
en rojo vuelven a ser negras y en la lista de importaciones del archivo “.java”, aparece la importación
realizada.
Figura 60: Resultado de la importación de la class “ActivityInfo”.
1.8.2 CAMBIO DE LA FUENTE DE LA LETRA
Se considera que, este tipo de recurso es mejor comprendido, si se trabaja con al menos dos tipos
diferentes de views. En este caso, el cambio de fuente será aplicado, a un TextView y a un EditText, a
partir de la siguiente metodología:
51
1. Insertar en la interfaz, un TextView y un EditText y asignarles, a cada uno, un id característico.

2. Copiar, en la subcarpeta font, el archivo de fuente de letra con extensión “.ttf”. Cuando se pegue
el archivo en la subcarpeta, se mostrará la siguiente ventana, donde se comprueba el nombre del
archivo y la ubicación del mismo.
Figura 61: Ventana de comprobación de las características del archivo de fuente de letra.
3. Teclear la siguiente línea de código, justo donde indica la Figura 62. Es importante resaltar que,
el nombre que se introduce en el id de las variables “TV” o “ET”, es el de la view en la interfaz
(paso 1); además, el valor de las variables “font_path”, es la referencia del archivo de fuente.
Línea de código:
setContentView(R.layout.activity_main);
TV = (TextView)findViewById(R.id.textView1);
String font_path1 = "font/ASMAN.TTF";
Typeface TF1 = Typeface.createFromAsset(getAssets(),font_path1);
TV.setTypeface(TF1);
ET = (EditText)findViewById(R.id.editText1);
String font_path2 = "font/ASMAN.TTF";
Typeface TF2 = Typeface.createFromAsset(getAssets(),font_path2);
ET.setTypeface(TF2);
52
Figura 62: Ubicación de la línea de código para la inserción de un archivo de fuente de letra.
el Android Studio. En este caso se refiere a la necesidad de importar la class “Typeface”, la cual
se puede importar presionando, simultáneamente, las teclas “Alt + Enter”
1.8.3 CREACIÓN DE ADVERTENCIAS Y CUADROS DE DIÁLOGO
Se ha decidido incluir 3 técnicas diferentes en este apartado: creación de advertencias (toast),

creación de cuadros de diálogo (AlertDialog) y cómo cerrar la aplicación mediante una acción. Con
el fin de aunar estas opciones en un solo ejemplo, se creará un AletrDialog que indique el cierre de la
aplicación. Si se pulsa “cancelar”, aparecerá un Toast, indicando que se ha cancelado la acción;
mientras que, si se pulsa “aceptar”, se cerrará la aplicación. A continuación, se explicarán por
separado estos métodos y luego se unirán en un ejemplo. Por último, se ejemplificará cómo llamar un
layout mediante un AlertDialog.
1.8.3.1 CREACIÓN DE ADVERTENCIAS
Una forma recurrente de crear una advertencia o Toast, es mediante el empleo de un método
público, el cual será asociado a un button, mediante la propiedad “onClick”. En la variable “toast” se
especifica entre comillas, el texto que se desea que aparezca en pantalla y el tiempo de duración del
mismo. En este caso, se ha utilizado “LENGTH_LONG”, que significa duración prolongada, como
se muestra en la siguiente línea de código.
53
Línea de código:
public void Alerta (View view) {
Toast toast = Toast.makeText(getApplicationContext(),"Haz pulsado
click",Toast.LENGTH_LONG);
toast.show();
}
1.8.3.2 CREACIÓN DE CUADROS DE DIÁLOGO
Los cuadros de diálogo o AlertDialog, son ventanas emergentes que se superponen a las views. Su
uso va destinado fundamentalmente a dos criterios: mostrar una información al usuario o pedirle que
seleccione una opción.
El empleo del AlertDialog, puede ser a través de un método público, el cual será asociado a una
view, como se ha explicado con anterioridad. El primer paso es declarar, dentro del onCreate, la view,
que va a ser encontrada mediante los recursos del sistema, en la interfaz y que va a contener el método
público de llamada del AlertDialog. En la siguiente línea de código, se crea el método público fuera
del onCreate y que contendrá el AlertDialog, en este caso, con dos opciones. Los recursos
“alerta.setTitle” y “alerta.setMessage”, son los encargados de mostrar el título y el contenido del
AlertDialog, respectivamente. Como se puede apreciar, el recurso “alerta.setNegativeButton/
alerta.setPositiveButton” crea las opciones que el usuario deberá seleccionar, sucedidas de un texto,
que deberá estar entre comillas. Esta herramienta tiene dos situaciones: “null” (que no ejecuta
acciones) o “DialogInterface.OnClickListener” (que crea otro método público que captura el click del
usuario para ejecutar acciones). El recurso “dialog.setCancelable(false)”, garantiza que el AlertDialog
no sea cerrado al dar click fuera de él, sino que, para que desaparezca, se deberá obligatoriamente,
pulsar sobre el “alerta.setNegativeButton” .
Línea de código:
public void MostrarDialog() {
AlertDialog.Builder alerta = new AlertDialog.Builder(this);
alerta.setTitle("Cuadro de Alerta");
alerta.setMessage("¿Quieres mostrar un Toast?");
alerta.setNegativeButton("Cancelar", null);
54
alerta.setPositiveButton("Aceptar", new DialogInterface.OnClickListener() {

@Override
public void onClick(DialogInterface dialog, int which) {
Toast toast = Toast.makeText(getApplicationContext(),"Haz mostrado un
Toast",Toast.LENGTH_LONG);
toast.show();
} } );
final AlertDialog dialog = alerta.create();

dialog.setCancelable(false);
dialog.show();
}
Nota: Si se quiere insertar un tercer botón, será a través de, por ejemplo:
“alerta.setNeutralButton("Recordar más tarde", null);”.
1.8.3.3 CIERRE DE LA APLICACIÓN
Lo primero que se debe aclarar en este tema, es que las clases, son la base de la programación
orientada a objetos y en Java son definidas como class. Una class es una plantilla que define la forma
de un objeto. En ella se almacenas datos y métodos que operarán sobre dichos datos. El recurso que
cierra una class es “finish()”. Si existiese una sola activity y, por ende, una sola pantalla en la
aplicación, para cerrar la misma, bastará con crear un método público, asociarlo a un button e insertar
la siguiente línea de código:
Línea de código:
public void Exit(View view) {
finish();
}
Si, por el contrario, existiesen varias pantallas, y se desea cerrar la class, una vez que se salga de
esta, se debe insertar “class_name.this.finish()” luego de la línea que corresponde a la navegación
entre activities. En la siguiente imagen, se muestra cómo, el sentido de navegación es de
“activity_main” a “activity_main_activity2” y cómo, al salir de la primera pantalla, esta se cierra.
55
Figura 63: Ubicación del código para cerrar una class.
1.8.3.4 EJEMPLO DE UN ALERTDIALOG PARA CERRAR LA APLICACIÓN CON

EMPLEO DEL TOAST
Como se ya anunció, ahora se mostrará un ejemplo que englobe las 3 técnicas diferentes anteriores,
mediante la creación de un AletrDialog, que indique el cierre de la aplicación. Si se pulsa “cancelar”,
aparecerá un Toast, indicando que se ha cancelado la acción; mientras que, si se pulsa “aceptar”, se
cerrará la aplicación.
Hablar de la cracion del método en el onCreate
Línea de código:
public void Alerta() {
alerta.setTitle("Cuadro de Alerta");
alerta.setMessage("¿Quieres cerrar la app?");
alerta.setNegativeButton("Cancelar", new DialogInterface.OnClickListener() {

@Override
Toast toast = Toast.makeText(getApplicationContext(),"Haz
cancelado",Toast.LENGTH_LONG);
toast.show();
} });
56
alerta.setPositiveButton("Aceptar", new DialogInterface.OnClickListener() {

@Override
finish();
} } );

dialog.show();
}
1.8.3.5 LLAMADA DE UN LAYOUT MEDIANTE UN ALERTDIALOG
Esta técnica es empleada, con mayor frecuencia, cuando se tiene una imagen en la interfaz y se
quiere que esta, al pulsarla, aumente su tamaño, mediante un AlertDialog. Antes de proceder a la
explicación de este ejemplo, se considera oportuno, aclarar que, el layout mostrado, funcionará como
una imagen, que puede abarcar todo el espacio del AlertDialog o no. Esto se debe a la posibilidad de
agregar los recursos, “alerta.setTitle”, “alerta.setMessage”, “alerta.setNegativeButton”,
“alerta.setPositiveButton” o “alerta.setNeutralButton”. De esta forma, el layout quedará en el medio
de dichos recursos: debajo de los dos primeros y encima de los últimos, en caso de agregarse.
1. Agregar una ImageView con id “imageView” y le asocio, mediante la opción “src”, la imagen
deseada, como se muestra en la siguiente imagen:
Figura 64: Inserción de la ImageView en la interfaz.
2. Crear el layout que se quiere mostrar, pulsaando click derecho en la subcarpeta layout dentro de
la carpeta res/New/Layout resource file, insertándole el nombre deseado al nuevo layout y se
aconseja que se establezca por defecto, un RelativeLayout, como se muestra a continuación:
57
Figura 65: Creación del nuevo layout.
3. Asignar el background del nuevo layout, como la imagen que contiene la ImageView del paso 1
y agregar un button, que será el encargado de cerrar el AlertDialog. Asignar al button el id
“buttoncerrarDialog”, como se observa en la imagen siguiente:
Figura 66: Diseño de la interfaz a mostrar en el AlertDialog.
4. Declarar, dentro del onCreate, la view (en este caso ImageView), que va a ser encontrada
mediante los recursos del sistema, en la interfaz y que va a contener el método público de llamada
del AlertDialog, mediante el método público “MostrarDialog”, como a continuación se muestra:
58
Figura 67: Ubicación de la view contenedora del método de llamada del AlertDialog.
5. En la siguiente línea de código, se crea el método público, fuera del onCreate y que contendrá el
AlertDialog.
Línea de código:
public void MostrarDialog() {
LayoutInflater inflater = getLayoutInflater();

View vista = inflater.inflate(R.layout.imagen,null);

dialog.setView(vista);
dialog.show();
vista.findViewById(R.id.buttoncerrarDialog).setOnClickListener(new
View.OnClickListener() {
@Override
dialog.dismiss();
} });
}
Nota: Las líneas “LayoutInflater inflater = getLayoutInflater()” y “View vista =
inflater.inflate(R.layout.imagen,null)”, hacen referencia a una variable que va a obtener el layout y a
59
otra variable llamada “vista”, que va a almacenar el layout, respectivamente. El recurso

“dialog.setView(vista)”, orienta a la variable “dialog” que muestre la variable “vista”, que es la que
contiene el layout que se quiere mostrar. Por último, se declara una view (en este caso un Button), que
va a ser encontrada mediante los recursos del sistema, dentro de la variable “vista” y se le orienta que
cierre el AlertDialog.
1.8.4 GUARDAR UN TEXTO Y RECUPERARLO TRAS CERRAR LA

APLICACIÓN
En ocasiones el usuario quiere guardar cierta información y recuperarla, a pesar de haber cerrado
aplicación. Esto se puede lograr creando un archivo de texto no visible en el dispositivo android. La
siguiente metodología explica cómo hacerlo posible:
1. Introducir un EditText y asignarle un id característico. Será en esta view, donde el usuario
insertará el texto que desee guardar y que, a su vez, es donde se recuperará el contenido.
2. Insertar dos buttons, uno para guardar el texto y otro para cargarlo en el EditText o donde se
requiera. Los pasos 1 y 2 son mostrados en la siguiente imagen:
Figura 68: Interfaz para guardar y cargar un texto.
3. Declarar la variable que va a encontrar el texto introducido por el usuario, en los recursos de
sistema y otra, especificando el tamaño del archivo de texto, que se creará en el móvil, como se
muestra a continuación:
60
Figura 69: Ubicación de las variables para conservar un texto tras cerrar la aplicación.
4. Crear dos métodos públicos, uno para guardar el texto y otro para recuperarlo, como se indica en
la siguiente línea de código:
Línea de código:
public void onClickGuardar(View v){
String nombre = oper1.getText().toString();
try{
FileOutputStream fos = openFileOutput("textFile.txt", MODE_PRIVATE);
OutputStreamWriter osw = new OutputStreamWriter(fos);
//Se escribe el String en el archivo

osw.write(nombre);
osw.flush();
osw.close();
// Se muestra que se ha guardado

Toast.makeText(getBaseContext(), "Guardado", Toast.LENGTH_SHORT).show();
oper1.setText(nombre);
}catch (IOException ex){
ex.printStackTrace();
} }
public void onClickCargar(View v){

try{
FileInputStream fis = openFileInput("textFile.txt");
InputStreamReader isr = new InputStreamReader(fis);
61
char[] inputBuffer = new char[READ_BLOCK_SIZE];

String s = "";
int charRead;
while((charRead = isr.read(inputBuffer)) > 0){
// Se convierten los char a String
String readString = String.copyValueOf(inputBuffer, 0, charRead);
s += readString;
inputBuffer = new char[READ_BLOCK_SIZE];

}
// Se establece, en el EditText, el texto que se ha guardado

oper1.setText(s);
// Se muestra un Toast con el proceso completado

Toast.makeText(getBaseContext(), "Cargado", Toast.LENGTH_SHORT).show();
isr.close();
}catch (IOException ex){
ex.printStackTrace();
} }
Nota: Se debe notar que, la recuperación del texto guardado tendrá lugar en el propio EditText en
el que fue creado, pero esto puede variar. El contenido guardado, puede ser llamado desde un
TextView, basta con declararlo al inicio del método púbico “onClickCargar”, lo cual pudiese ser de
la siguiente manera: “TextView texto_cargado = (TextView)findViewById(R.id.textView_cargar)”
(considerando que la view tenga como id: “textView_cargar”). Por último, se establece que, en el
TextView, es donde se cargará el texto guardado, de la siguiente manera: “texto_cargado.setText(s)”
62
1.8.5 TRABAJO CON LOS RADIOBUTTON
Si en una misma activity, existen varios conjuntos de RadioButton, es aconsejable que, cada
conjunto de view, sea agrupada en un RadioGroup. La siguiente línea de código se debe repetir por
cada RadioButton y por cada RadioGroup, teniendo en cuenta que, se debe especificar, para cada
RadioButton, cuántos RadioButtons más hay en el grupo y declarar que, si él (el RadioButton al que
se hace referencia) es seleccionado, los demás deben desmarcarse.
Nota: Sólo se expone, a modo de ejemplo, cómo queda el código, para los dos primeros
RadioButtons de un mismo grupo.
Línea de código:
//primer grupo
public void primer_RadioButton (View view) {
RadioButton rad1 = (RadioButton) findViewById(R.id.radioButton);
RadioButton rad2 = (RadioButton) findViewById(R.id.radioButton2);
rad1.setChecked(true);
rad2.setChecked(false);
}
public void segundo_RadioButton ( View view) {

RadioButton rad1 = (RadioButton) findViewById(R.id.radioButton);
rad2.setChecked(true);
}
63
1.8.6 SPINNER
Fes
1. Insertar un Spinner, en la interfaz y asignarle un id característico.
Sds
Figura 70: Ubicación del Spinner.
2. Ib
Sdss
3. Edrftgyhuj
ssd
Figura 71: Localización de las variables a crear para la inserción de un Spinner.
Hablar de los adaptadores que definen la forma en la que se van a mostrar las opciones del spinner.
Línea de código:
lista = (Spinner)findViewById(R.id.ListaSpinner);
64
ArrayAdapter<String> adaptador = new ArrayAdapter<String>

(this,android.R.layout.simple_spinner_item,datos);
lista.setAdapter(adaptador);
lista.setOnItemSelectedListener(new AdapterView.OnItemSelectedListener() {
@Override
public void onItemSelected(AdapterView<?> adapterView, View view, int position, long
id) {
switch (position){
case 0:
break;
case 1:
Toast toast1 = Toast.makeText(getApplicationContext(),datos
[position],Toast.LENGTH_LONG);
toast1.show();
break;
case 2:
toast2.show();
break;
case 3:
toast3.show();
break;
} }
@Override
public void onNothingSelected(AdapterView<?> parent) {
} });
65
Nota: En el método público “onItemSelected”, “position” se refiere al lugar de selección de las

opciones del Spinner. Es por esta razón que, en el Toast, se pide el valor de la variable “datos” en la
posición en la que fue seleccionada. El case 0, en Java, se refiere a la primera situación que, en este
caso, es “Lista desplegable”. Es recomendable no imponerle acciones u omitirla, pues, en caso
contrario, se ejecutaría la acción de la primera opción del Spinner, de manera automática y, en
ocasiones, esto no es lo el usuario desea.
1.8.7 VALIDACIÓN DE CAMPOS VACÍOS
En ocasiones si los Text Fields, se encuentran vacíos en el momento de ejecutar el método en el

que están involucrados, la aplicación falla. Con el objetivo de erradicar este problema, se propone
orientar una acción, si el componente se encuentra vacío. En este caso es un Toast, pero pudiera ser
cualquier otra acción.
1. Declarar, justo debajo de de la class, tantas variables de tipo EditText, como Text Fields se
encuentren en la interfaz, que el usuario pudiese dejar en blanco. Ejemplo de esto es: “EditText
oper1, oper2”.
2. Declarar en el onCreate, las variables de tipo EditText que van a encontrar los Text Fields en la
interfaz, mediante los recursos del sistema, como, por ejemplo: “oper1 = (EditText)
findViewById(R.id.NombreDeLaViewEnElLayout)”.
3. Declarar un método público que evalúe los campos vacíos.
Línea de código para evaluar si un campo está vacío:

public void CostoElectrico (View view) {
String lis = this.oper1.getText().toString();
String lfs = this.oper2.getText().toString();
if (lis.equals("")|lfs.equals("")) {
Toast.makeText(this, "Debe escribir las dos lecturas", Toast.LENGTH_LONG).show();
}
else {
} }
Nota: Antes de evaluar el campo vacío mediante la función “equals”, las variables de tipo EditText,
deben ser convertidas en String.
66
CONCLUSIONES
Con el estudio detenido de este trabajo, el lector debe ser capaz de crear sus primeras aplicaciones
y reproducir disímiles técnicas, con un conocimiento básico de programación. Se ha profundizado en
la estructura interna del Android Studio, principalmente en la interfaz del usuario y el empleo de las
componentes gráficas.
No se detallaron temas propios de la programación en Java, sino que se abordaron de manera
natural, debido a la estrecha interrelación que ofrece Android Studio con el código de lenguaje. Esto
queda evidenciado con la inserción de distintos tipos de archivos, que requieren una línea de código,
para ser insertados en la app o con el empleo de algunas views, que también requieren un mínimo de
programación.
Se espera que, mediante la conceptualización y definición de las secciones y componentes del
programa, el futuro programador se familiarice con temas que, en un principio, pueden resultar
complejos y sea impulsado a profundizar en estos aspectos. Queda establecida así, una herramienta
para el aprendizaje de un software de programación, con una interfaz amigable para el usuario y que
va a la par con el entorno de desarrollo.
67
BIBLIOGRAFÍA
1. ABLESON, Frank. “Guía para desarrolladores”. 2ª Edición. Anaya, 2011.

2. FRIESEN, Jeff. “Java para desarrollo Android”. Edición 2011. Anaya, 2011.
3. GARCÍA DE JALÓN, Javier et al. “Aprenda Java como si estuviera en primero”. San Sebastián,
2000.
4. GARGENTA, M. y NAKAMURA, M. “Learning Android”. 2ª ed. Boston: O'Reilly Media, 2014.
5. GERBER, A. and CRAIG, C. “Learn Android Studio”. ISBN: 978-1-4302-6602-0. 2015.
6. MONTERO MIGUEL, Roberto. “Desarrollo de aplicaciones para Android”. Edición 2014.
7. PHILLIPS, Bill. et al. “Programación con Android”. Edición 2016.
8. RIBAS LEQUERICIA, Joan. “Desarrollo de aplicaciones para Android”. Edición 2018.
9. TOMAS GIRONES, Jesús. “El gran libro de Android”. 4ª Edición. Marcombo, 2011.
68
View publication stats

Primer Acercamiento AndroidStudio

Cargado por

Copyright:

Formatos disponibles

Primer Acercamiento AndroidStudio

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Primer Acercamiento AndroidStudio

Cargado por

Copyright:

Formatos disponibles

See discussions, stats, and author profiles for this publication at: https://www.researchgate.

Primer acercamiento al Android Studio

Chapter · June 2020

Marlon Mederos Corrales

The user has requested enhancement of the downloaded file.

MSc. Marlon Mederos Corrales

Universidad Tecnológica de La Habana

Monografía, CUJAE, 2021

1. Android Studio ............................................................................................ 2

1.1 Glosario de términos de Android Studio ......................................................................... 3

1.2 Creación de un nuevo proyecto y de una activity............................................................ 7

1.3 Creación de un Android Virtual Device (AVD)............................................................ 11

1.3.1 Emulación y depuración del proyecto ................................................................... 14

1.4 Carpetas y subcarpetas del sistema ............................................................................... 16

1.4.1 Carpetas del sistema: ............................................................................................. 16

1.4.2 Subcarpetas del sistema:........................................................................................ 18

1.5 Interfaz de usuario y archivos .xml ............................................................................... 26

1.5.1 Palette .................................................................................................................... 28

1.5.2 Component Tree .................................................................................................... 34

1.6 Inserción de distintos tipos de archivos ......................................................................... 36

1.6.1 Inserción de imágenes y cambio del ícono ............................................................ 38

1.6.2 Inserción y reproducción de archivos de audio ..................................................... 42

1.6.3 Inserción y reproducción de videos ....................................................................... 44

1.7 Navegación entre activities ........................................................................................... 46

1.7.1 Creación de una nueva activity ............................................................................. 46

1.7.2 Navegación entre activities ................................................................................... 48

1.8 Diferentes técnicas dentro de Android Studio ............................................................... 50

1.8.1 Bloqueo de la orientación de la pantalla ............................................................... 50

1.8.2 Cambio de la fuente de la letra .............................................................................. 51

1.8.3 Creación de advertencias y cuadros de diálogo ..................................................... 53

1.8.4 Guardar un texto y recuperarlo tras cerrar la aplicación ....................................... 60

1.8.5 Trabajo con los RadioButton ................................................................................. 63

1.8.6 Spinner .................................................................................................................. 64

1.8.7 Validación de campos vacíos ................................................................................ 66

Figura 34: Carpeta Widgets de la pestaña Palette. ....................................................................... 30

Figura 68: Interfaz para guardar y cargar un texto. ...................................................................... 60

El teléfono móvil, recurrentemente, se encuentra al alcance de su propietario, siendo uno de los

El sistema operativo de código abierto (open source), android, principalmente es programado en

Figura 1: Software de programación para dispositivos móviles Android Studio.

1.1GLOSARIO DE TÉRMINOS DE ANDROID STUDIO

• API: Interfaz de Programación de Aplicaciones, es el conjunto de funciones y procedimientos

1.2CREACIÓN DE UN NUEVO PROYECTO Y DE UNA ACTIVITY

Figura 2: Ventana principal en la inicialización de Android Studio.

Posteriormente, aparece la ventana de configuración del proyecto. En el primer diálogo se

Figura 3: Ventana de configuración del proyecto.

En la siguiente ventana se especifican el tipo de dispositivo para el cual se programará y la menor

Figura 4: Ventana de selección de tipo de dispositivo y de versión android.

En la siguiente ventana se escoge la plantilla de activity con la cual se iniciará el proyecto. Si se

Figura 5: Ventana de selección de tipo de activity inicial.

Consecutivamente, se pueden nombrar los diferentes aspectos de la activity. Generalmente se

Figura 6: Ventana de opciones de la activity.

A continuación, se observa, luego de estas configuraciones iniciales, el entorno de Android Studio,

Figura 7: Entorno Android Studio.

1.3CREACIÓN DE UN ANDROID VIRTUAL DEVICE (AVD)

Un paso natural en la creación de aplicaciones, consiste en probar las mismas en dispositivos

Figura 8: Ubicación del AVD Manager.

2. Crear un ADV, seleccionando el botón “Create a virtual device”.

Figura 9: Creación de una máquina virtual.

Figura 10: Selección del tipo de dispositivo virtual.