Desarrollo de aplicaciones

android 4.X.
 Índice de contenidos
Introducción............................................................................................................................................................... 3
Introducción y objetivos ................................................................................................................................. 3
Conceptos previos ........................................................................................................................................... 3
Arquitectura Android ...................................................................................................................................... 4
Entornos de desarrollo............................................................................................................................................. 6
Introducción ..................................................................................................................................................... 6
Android Studio ................................................................................................................................................. 6
Hola mundo, mi primera aplicación Android ...................................................................................................... 26
Fundamentos de las aplicaciones Android .......................................................................................................... 36
Gradle.............................................................................................................................................................. 36
Componentes de aplicación......................................................................................................................... 38
AndroidManifest ............................................................................................................................................ 40
Recursos ......................................................................................................................................................... 42
Interfaz de usuario.................................................................................................................................................. 43
Recursos................................................................................................................................................................... 63
Introducción ................................................................................................................................................... 63
Imágenes ........................................................................................................................................................ 63
Strings ............................................................................................................................................................. 64
Estilos y colores.............................................................................................................................................. 65
Acceso a los recursos .................................................................................................................................... 65
Ejemplo de uso .............................................................................................................................................. 66
Almacenamiento ..................................................................................................................................................... 75
Introducción ................................................................................................................................................... 75
Almacenamiento Interno.............................................................................................................................. 76
Almacenamiento Externo ............................................................................................................................. 77
Shared Preferences ....................................................................................................................................... 79
Base de Datos SQLite .................................................................................................................................... 82
Sensores................................................................................................................................................................... 84
Servicios Web........................................................................................................................................................... 86
Introducción ................................................................................................................................................... 86
Hilos................................................................................................................................................................. 87
AsyncTask ....................................................................................................................................................... 89
Servicio............................................................................................................................................................ 92
Ejemplo de Aplicación ................................................................................................................................... 95
Resumen ................................................................................................................................................................ 100

Página 2 de 100
Introducción

Introducción y objetivos

Esta unidad será la toma de contacto con el Sistema Operativo Android, una breve descripción sobre
su arquitectura, características y los conceptos básicos esenciales para comenzar a desarrollar aplicaciones
sencillas en esta plataforma.

Al finalizar esta unidad serás capaz de:

• Tener una visión general del Sistema Operativo (S.O.).

• Conocer y saber utilizar sus herramientas de desarrollo.

• Conocer estructura básica de una aplicación.

• Generar interfaces de usuario y nociones de customización de los mismos.

• Dónde y cómo guardar la información de las aplicaciones.

• Sensores disponibles.

• Cómo consumir recursos de la nube.

La documentación del curso está actualizada según las últimas especificaciones oficiales proporcionadas por
Android Developers (Android 5.0 y posteriores).

Conceptos previos

Android es el S.O. móvil más extendido en el mercado con cuotas de venta que solamente en España han
llegado a alcanzar el 80%. A esto debemos sumarle una curva de aprendizaje muy corta en relación con otros
lenguajes de programación actuales.

Hasta aquí suena bien y otra de las características importantes es su alto nivel de “customización”. Es decir,
brinda una gran capacidad para crear interfaces muy amigables al usuario.

Por último, y no menos importante, las herramientas de desarrollo para Android son gratuitas y la licencia
necesaria para publicar en Google Play es muy asequible, lo que hace que existan más de 2 millones de apps
solo en Google Play.

Por estas razones, Android es uno de los Sistemas Operativos móviles más extendidos del mundo.

Página 3 de 100
Arquitectura Android

El S.O. Android está basado en varias capas bien diferenciadas:

Imagen basada en la documentación oficial Android Developers Arquitectura plataforma a fecha 27/09/18

Esta imagen representa un esquema de la disposición en capas de la Arquitectura Android. A continuación

vamos a ver de manera más extensa cada una de ellas.

Kernel de Linux

Página 4 de 100
Es el núcleo del S.O. responsable de los servicios básicos, de los controladores hardware y del administrador
de energía.

Capa de abstracción hardware (HAL)

Hace de puente entre los dispositivos hardware y el software de más alto nivel (API Java) que permite su uso.
Proporciona las interfaces de los diferentes componentes hardware.

Android Runtime
Actualmente implementa ART que supone una mejora importante frente a versiones de Android anteriores
que implementaban Dalvik como componente principal de la máquina virtual de Java. Ahora mismo se permite
la ejecución de varias máquinas virtuales.

Es muy importante recordar que una aplicación escrita para Android 5.0 o superior debería funcionar sobre
versiones anteriores del mismo pero no tiene porqué ocurrir el caso inverso.

Bibliotecas Nativas C/C++

Se trata de un conjunto de librerías nativas del S.O. escritas en C/C++ que son las responsables del
rendimiento estable de los diferentes componentes.

Durante el desarrollo de las aplicaciones se podrá acceder a ellas para realizar funciones principalmente
relacionadas con la manipulación de gráficos 2D y 3D bien a través de la API Java (la opción más común) o
incluso a través de los propios NDK de Android en el caso de desarrollos nativos C/C++ (Desarrollos especiales).

Framework Java API

Es uno de los cimientos para construir las apps Android. A través de esta API Java se proporciona acceso a
todas las funcionalidades del Sistema Operativo:

• Sistema de vistas. Contiene todos los elementos básicos para crear las interfaces de usuario (cuadros de
texto, botones…).

• Administrador de recursos. Permite el acceso a los strings (usados para facilitar el multilenguaje),
gráficos o estilos (ambos utilizados para customizaciones principalmente).

• Administrador notificaciones. Para poder mostrar las diferentes alertas de las aplicaciones.

• Administrador de actividad. Se encarga de gestionar el ciclo de vida de las apps y genera también la pila
de retroceso en navegación, una "lista" donde se van guardando diferentes estados de las apps que se
han usado en el dispositivo.

• Proveedores de contenido. Gracias a ellos se permite el intercambio de datos entre diferentes apps.

Apps del sistema

Son un conjunto de aplicaciones que vienen por defecto en Android, como puede ser email, SMS, navegación…
En este punto hay que recordar que Android siempre brinda la posibilidad de utilizar otras en su lugar, pero
cuando desarrollamos una app podemos recurrir a estas integradas para dotarla de ciertas capacidades (envío
de SMS, correo, etc.) y así no tener que implementar toda la funcionalidad completa.

En este punto deberías tener una mejor idea de qué es el S.O. Android y las partes más importantes que lo
integran. Durante el resto de pantallas iremos introduciendo todas las herramientas y conceptos (primero
básicos y luego algo más avanzados) necesarios para el desarrollo de apps en Android.

Página 5 de 100
Entornos de desarrollo

Introducción

Inicialmente uno de los mejores entornos de desarrollo fue Eclipse con sus plugins especiales para Android,
en un tándem que se acabó conociendo como Eclipse +ADT. Con el paso del tiempo apareció un nueva
herramienta de desarrollo llamada Android Studio.

En sus inicios generaba alguna pequeña incidencia con el emulador de dispositivos, por lo que algunos
desarrolladores usaban también emuladores con ciertas funciones de análisis del tipo Genymotion.

Actualmente Android Studio ha mejorado mucho y con sus emuladores tenemos características suficientes
para probar nuestras aplicaciones, aunque no se debe olvidar que, dependiendo de qué tipos sean (sobre todo
apps de geolocalización, conexiones Bluetooth, Wifi...), siempre es mejor realizar la prueba en un terminal real.

A partir de este momento seleccionaremos Android Studio como herramienta de referencia, y realizaremos
todos los desarrollos y explicaciones basándonos en ella.

Android Studio

Android Studio es el entorno de desarrollo oficial para aplicaciones Android. A lo largo del curso ser
indicará el proceso de instalación (en Windows) y luego se destacarán algunas de sus funciones más
importantes que se utilizan con más regularidad en los desarrollos.

Siempre se podrá disponer de más documentación sobre esta herramienta en la web oficial de Android Studio.
Instalación

En primer lugar se procederá a la descarga del ejecutable desde el apartado de descarga. Una vez finalizada se
ejecutará el .exe y comenzará la instalación.

Página 6 de 100
En esta imagen se aprecia cómo el sitio de descarga identifica el S.O. de la máquina conectada y ofrece la
descarga adecuada al mismo.

Para iniciar la descarga será necesario aceptar sus términos y condiciones tal y como refleja esta imagen.

Página 7 de 100
En este punto la descarga del entorno Android Studio habrá comenzado y deberá aparecer en la esquina
inferior izquierda del navegador. Una vez finalizada ejecutamos el .exe y comenzará la instalación.

Este proceso es bastante automático, aun así lo describiremos paso a paso para evitar posibles errores en
algunos puntos.

Tras los pasos anteriores, comienza la fase de instalación. Presta atención a cómo realizarla:

Esta es la pantalla principal de inicio de la instalación y simplemente debemos pinchar sobre “next” para
continuar.

Página 8 de 100
En el siguiente paso puedes ver los componentes que formarán parte de la instalación. En el caso de utilizar un
emulador externo (por ejemplo Genymotion) se podría prescindir del “Android Virtual Device” (como consejo,
te recomendamos utilizar siempre las configuraciones por defecto).

Página 9 de 100
Como se ve en esta imagen, el instalador permite seleccionar el lugar destino de la instalación del
programa como cualquier otro que instalemos (como recomendación, puedes dejar la ruta por defecto).

Página 10 de 100
En esta pantalla se selecciona dónde colocar el acceso rápido a la aplicación. Es indistinto y dependerá 100%
de la forma en la que el desarrollador organice su equipo de trabajo.

En esta imagen puedes ver el inicio y el fin de la instalación.

Página 11 de 100
Al llegar a este punto, la instalación de Android Studio se ha completado correctamente.

Ahora comenzaría el proceso de configuración básico del entorno y la instalación de los “SDKs Android”
que se irán describiendo a lo largo de las siguientes pantallas.

Como es un proceso diferente podrá realizarse una vez finalizada la instalación o bien cuando se acceda al
entorno por primera vez. En nuestro caso suponemos que se decide iniciar Android Studio una vez finalizada
la instalación.

Página 12 de 100
El primer punto de la configuración que aparecerá hace referencia a la posibilidad de importar
configuraciones anteriores.

En el caso de una primera instalación no se dispondrá de configuraciones previas, pero conforme se

produzcan actualizaciones de la herramienta se podrán importar esas personalizaciones anteriores del
entorno.

Página 13 de 100
Esta es la pantalla de bienvenida.

Página 14 de 100
En esta pantalla se permite escoger el tipo de configuración del entorno.

Para principiantes conviene seleccionar la configuración “standard”. Con el tiempo, y en función del tipo de
apps que se deseen desarrollar, puede ser necesario una configuración más específica, aunque el modo
estándar cumple los requisitos de la gran mayoría de desarrolladores.

Página 15 de 100
Esta imagen hace referencia al conjunto de colores generales que se utilizarán en el entorno (apariencia,
temas…) pero que pueden cambiarse en cualquier momento a través del menú Preferencias del entorno. En
este punto interviene un poco el gusto del usuario, además de diferentes consideraciones de “higiene en el
puesto de trabajo”. Ante un pantalla con tonos claros, por ejemplo, la vista se cansa más que si se utiliza un
entorno en tonos oscuros que facilitan la lectura.

Como recomendación, y debido al número de horas que se suele necesitar delante de la pantalla, para un
desarrollo es mejor los colores oscuros como los que aporta el tema “darcula” de este entorno. A título de
curiosidad, efectivamente este nombre es un guiño de los desarrolladores.

Página 16 de 100
Cuando se llega a esta pantalla se muestran los diferentes componentes del SDK que se desean instalar. En
esta configuración del entorno se instalarán los mínimos para realizar apps.

Una vez dentro del entorno se dispondrá de un menú especial para instalar, desinstalar o actualizar estos
componentes (un poco más adelante se hablará de ellos con más profundidad) aunque también existe la
opción, desde este menú, de volver atrás y realizar una instalación más personalizada. La recomendación es
utilizar configuraciones por defecto y, una vez instalado y configurado el entorno, personalizarlo.

Una vez llegamos a esta pantalla el entorno de desarrollo ya estaría listo para utilizarse.

Página 17 de 100
Vamos a hacer un pequeño inciso para referirnos a los componentes SDKs Android.

Son el conjunto de herramientas para el desarrollo Android, que ofrecen diferentes funcionalidades
dependiendo de la API con la que se trabaje en cada momento, de ahí su importancia y necesidad de
actualización constante.
Debido a la evolución de Android hay APIs que ya están obsoletas, por lo que las aplicaciones suelen necesitar
un mantenimiento constante, sobre todo cuando en una nueva versión de la API se producen cambios muy
sustanciales.

A través de las publicaciones en Android Developers se pueden consultar los cambios o actualizaciones
necesarias en las apps publicadas con anteriores versiones.
Desde la pantalla anterior, a través del menú “configure” de la parte inferior derecha, se podrá acceder al
“SDK Manager”, que no es más que un gestor de las diferentes versiones de SDKs disponibles.

En esta captura puedes ver los SDKs que la instalación realiza por defecto y que ya se podrían utilizar para
crear una nueva app.

Como desarrollador se debe prestar especial atención al “SDK platform” (las APIs) y al “SDK tools” (conjunto
de herramientas para el desarrollo en Android) que son los dos aspectos del SDK que varían con las versiones
y que se deben ir actualizando o instalando versiones nuevas. También puede pasar que por el tipo de app a
desarrollar se necesite instalar un nuevo componente que con anterioridad no hacía falta.

Página 18 de 100
Normalmente el del SDK aparecerá comprimido y como no se utilizan todas sus partes por motivos de espacio,
no se suele instalar completo.

En la última imagen se muestra el contenido real instalado. Para la “versión extendida” debe estar seleccionado
el recuadro inferior derecho “Show Package Details”.

Seleccionando sobre los recuadrados situados a la izquierda se indicará si se desea instalar o desinstalar
los diferentes componentes antes de pulsar "Aplicar" como puedes ver en la imagen.

Página 19 de 100
Hasta aquí todo lo correspondiente a la instalación y configuración del entorno. En el siguiente punto se
detallarán los elementos más comunes que suelen utilizarse en la mayoría de los desarrollos.

Para más información sobre la instalación de Android Studio puede acudirse al apartado de instalación de la
web oficial.

Para finalizar, hay que puntualizar que en algunos sistemas Windows pueden producirse errores como si la
instalación del JDK de Java no se hubiera producido. Para resolver este problema se debe crear una variable de
entorno que apunte a la ubicación del JDK (puedes encontrar más información en el enlace anterior).
Visión general

Una vez conocido el proceso de instalación de la herramienta para el desarrollo y algunos problemillas que
pueden surgir durante el proceso, es hora de ver alguna de las características más importantes del entorno.

En esta imagen tienes el primer menú que da acceso a la herramienta de desarrollo y en la que se aprecian
varias partes:

Recuadro rojo
El acceso rápido. Es lo mismo que la función de archivos recientes de otros programas, e incluye una lista con
los proyectos sobre los que se ha estado trabajando últimamente.

Recuadro azul
Se dispone de las opciones comunes para acceder a un proyecto, bien creando uno desde cero, bien
accediendo a un proyecto creado con anterioridad.

Recuadro verde
Con las opciones resaltadas en este recuadro se pueden importar proyectos de versiones anteriores de
Android Studio, o incluso de otras herramientas de desarrollo como podría ser Eclipse+Adt.

Recuadro naranja
Este es el menú de acceso a la configuración desde el que se pueden actualizar los SDKs o incluso la propia
versión del entorno. Existen también otras configuraciones más específicas que se mencionarán más adelante.

Página 20 de 100
Aquí se puede ver el aspecto general que tomará el editor una vez se accede a un proyecto o se crea uno
nuevo (pueden aparecer algunas mínimas variaciones con respecto a la imagen en función de la versión y la
configuración aplicada).

En la parte superior están ubicados los menús de acceso, más abajo se dispondrá de una serie de accesos
rápidos conocidos como barra de herramientas y, siguiendo hacia abajo, aparece la llamada barra de
navegación que indica la URL del archivo que se estaría mostrando en ese momento. Justo debajo, y al mismo
nivel, comienza una de las ventanas de herramientas y la barra de la ventana de herramientas.

En la imagen no se aprecia una serie de ventanas de herramientas extra que pueden aparecer durante el
desarrollo y la ventana del editor donde se podrá escribir y modificar el código fuente de la aplicación.

Menús de acceso

Son una serie de botones que permiten desplegar los diferentes menús del entorno.

Página 21 de 100
En el menú Preferencias podemos encontrar desde ajustes de apariencia, color y tema hasta el acceso a los
Android SDK con opciones de instalación y desinstalación.

Otro menú que se puede necesitar habitualmente (sobre todo cuando desaparecen botones o ventanas de la
herramienta) es el View a través del cual se obtiene acceso a los diferentes menús que deberían aparecer en
el entorno por defecto.

Permite mostrar/ocultar dichos menús.

Página 22 de 100
Por último, el menú Build irá teniendo más importancia en los desarrollos según estos adquieran mayor
complejidad.

Son especialmente destacables las opciones “clean project” y “rebuilt project”, las primeras a recurrir
cuando aparezca algún error en el código porque no se reconoce una importación, controlador o alguna
configuración o similares.

Como consejo, cuando no se detecte bien un error o genere dudas al respecto, antes de modificar nada
siempre "clean project" y "rebuild project".

Página 23 de 100
Barra de herramientas (accesos directos)

Esta barra de herramientas permite un acceso rápido a diferentes utilidades normalmente accesibles desde
los menús superiores. Se utilizará mucho el icono de Play (run, para ejecutar la aplicación) y el Play con una
pequeña cucaracha (ejecución en modo debug).

En siguientes puntos se hará más hincapié en estos dos modos de ejecución.

Ventanas de Herramientas y Barra de la ventana de herramientas

Ambos elementos se encuentran relacionados. Con los botones de la “barra de la ventana de herramientas”
se modifica el contenido de estas y se muestran u ocultan ventanas nuevas. Cabe destacar “proyectos” y las
relacionadas con la ejecución de las apps, como puede ser “logcat“ o “run”.

En cuanto a "Project" se puede disponer de dos visualizaciones diferentes: bien como “android” que permite
ver los elementos del proyecto según la estructura de una aplicación Android (se detallará la estructura en el
punto siguiente) o bien como la estructura de directorios de proyecto, “Project files”.

Página 24 de 100
Con esto finalizaría la introducción al entorno de desarrollo. Para tener información adicional sobre algún
punto concreto puedes consultar el siguiente enlace de la documentación oficial Android Studio entorno.

Página 25 de 100
Hola mundo, mi primera aplicación Android
El primer paso importante cuando se comienza a estudiar un lenguaje es la primera aplicación. En este caso, y
como suele ser normal en muchos lenguajes de desarrollo, se realizará el clásico ”Hello World u Hola Mundo”.

Se comenzará creando un nuevo proyecto, bien desde el menú de bienvenida o bien desde el menú superior
“File”.

Para crear un nuevo proyecto desde el menú de bienvenida se deberá pinchar sobre “Start a new Android
Studio Project” tal como aparece resaltado en la imagen.

Página 26 de 100
A continuación, es necesario ponerle nombre a la aplicación e indicarle su nombre de paquete (importante, ya
que el identificador en Google Play son estos dos, cuya unión debe ser única). La notación del “company
domain” o nombre de paquete será en minúscula y del estilo “nombreidentificativo.com (u org)”, por ejemplo
“miaplicacion.com”.

Sin embargo, el nombre de aplicación utilizará el nombrado “Camel Case” de forma que sería “HolaMundo”. El
identificador final quedaría de la siguiente forma com.miAplicacion.holaMundo.

Por el momento no indicaremos nada más, ya que los includes de la parte inferior se utilizan en desarrollos
más avanzados y simplemente sirven para señalar que se utilizarán, o no, en el proyecto actual.

Página 27 de 100
Puede parecer algo extraño pero esta imagen hace referencia al objetivo (target) del desarrollo en curso. Es
muy importante, y siempre y cuando las características propias del desarrollo lo permitan, buscar la mayor
compatibilidad posible. ¿Cómo se consigue esto?

Se debe seleccionar como objetivo la versión de API más baja posible (Android Studio proporciona además
indicaciones sobre el porcentaje de dispositivos que se alcanzaría con esa versión). En esta pantalla se debe
seleccionar también si la aplicación será para teléfono, tablet, reloj o TV. Por el momento nos centraremos
únicamente en el desarrollo para teléfono y tablet.

Página 28 de 100
Tras seleccionar el target aparecerá una pantalla con gran variedad de Activitys donde se deberá seleccionar
empty activity que es el modelo básico sobre el que ir desarrollando. Para entenderlo un poco mejor, la
activity contendrá todo el código funcional de la pantalla en cuestión.

Es en este momento cuando se accede a una nueva ventana donde se permite configurar en la activity tanto su
nombre “Activity Name” (código Java) y su nombre de recurso asociado ”Layout Name” (xml representación
de la pantalla). Es importante marcar el recuadro para la compatibilidad.

Ahora sería un buen momento para dejar al ordenador trabajar unos minutos, ya que comienza la
construcción del proyecto y, en función de la versión del gradle o la potencia de la máquina, puede llegar a
demorarse un buen rato.

Página 29 de 100
Con esto finalizaría la creación del proyecto "Hola mundo" creado por defecto pero... ¿cómo saber si la app
realmente funciona?

Habría varias respuestas a esta pregunta, aunque la forma de obtener la más sencilla es ejecuctar la
aplicación y comprobar si realmente cumple con las funcionalidades estipuladas.

Para este tipo de pruebas se dispone de dos herramientas principales:

Teléfonos Android
Teléfonos Android con el modo desarrollador activado y el permiso para instalar "aplicaciones de origen
desconocido” (esto se considera cualquier app fuera de Google Play). Para esta opción el teléfono debe estar
conectado al pc mediante un cable y, en el caso de Windows, es muy importante que los drivers estén
correctamente instalados, o no funcionará.

Página 30 de 100
Al conectar por primera vez un teléfono al ordenador suele ser necesario aprobar una serie de permisos
(como mencionamos, para aplicaciones complejas o que requieren el uso de tecnologías como GPS, NFC,
Bluetooth…. siempre se recomienda probar las apps en terminales reales).

Emuladores
La otra opción es el uso de emuladores, ya sea el propio de Android o aplicaciones del tipo Genymotion.
En este caso se realizará la prueba sobre un emulador y se supondrá que no existe ninguno creado con
anterioridad.

El primer paso para crear un emulador Android con Android Studio es acceder al AVD Manager, que es el
gestor de emuladores. Se puede acceder bien vía “menú tools” o bien a través de su icono de acceso directo
en la barra de herramientas.

Página 31 de 100
Aparecerá una lista con todos los emuladores disponibles creados con anterioridad. Para la documentación
se supondrá no hay ninguno disponible y se explicará cómo crear uno nuevo.

Se comenzará pulsando sobre el botón “Create new device” que proporciona acceso a la pantalla de
configuración del hardware del dispositivo, donde se deberá escoger el tipo de terminal que se desea (en este
caso, un Nexus 6 del cual pueden verse características como tamaño o densidad de pantalla).

Página 32 de 100
A continuación viene la selección de software, entendiendo por software, en este caso, la versión de la API
Android que se desee emular (mínimo la seleccionada como objetivo en el proyecto).

Página 33 de 100
Por último aparecerá una pantalla resumen con las selecciones realizadas y la posibilidad de ponerle un
nombre personalizado al emulador.

De vuelta al gestor de emuladores se puede comprobar cómo el nuevo emulador se ha creado

correctamente.

Ahora ya se estaría en disposición de lanzar (ejecutar) la app. Para ello se debe pulsar en el botón Run (símbolo
play) bien a través del acceso rápido en la barra de herramientas o bien a través del menú “Run” de la parte
superior.

Página 34 de 100
Tras pulsar el botón Run debería aparecer un pop up (menú emergente) desde el cual se podrá seleccionar
el lugar donde se desea ejecutar la app. Podría seleccionarse como destino un terminal real o alguno de los
emuladores disponibles (en este caso se utilizará el emulador creado).

Página 35 de 100
Una vez seleccionado el emulador comenzará la carga del mismo que puede llevar un tiempo (en función de
las características de nuestro ordenador) a menos que ya se hubiera ejecutado con anterioridad y
permaneciera activo. Finalizada, se instalará y ejecutará la aplicación en el emulador.

Como puedes apreciar en la última imagen, la app funciona correctamente y muestra el mensaje “Hello
World” (Hola Mundo) por pantalla.

Al crear el proyecto han aparecido una serie de conceptos nuevos como puede ser el de activity o el layout
resource.

Será en el siguiente punto donde se entre en más detalle sobre las partes fundamentales de una app Android.

Fundamentos de las aplicaciones Android

Gradle

Puede haber diferentes clasificaciones en función de los autores en los que se esté basando o siguiendo un
desarrollador. Normalmente, y ajustándose a la documentación oficial, se hablaría de 3 grandes grupos:

• componentes de aplicación

• archivo manifest (androidmanifest)

• recursos

Página 36 de 100
Gradle es el sistema de compilación usado por Android Studio. Se trata de un plugin a parte de la propia
herramienta para poder facilitar su actualización y la exportación entre proyectos.

Se dispone de un archivo de proyecto y uno de aplicación. En el primero destaca la versión de gradle que
se está utilizando en ese momento. En versiones anteriores hubo problemas en algún punto del desarrollo y
una de las soluciones mayoritarias que proponían los desarrolladores era utilizar versiones previas de gradle.
Desde este archivo se realizaría la modificación.

Página 37 de 100
Sin embargo, el segundo archivo contiene diferentes tipos de información aunque todos ellos ligados a
En la “etiqueta” dependencies se encuentran, aunque suene redundante, las dependencias de la aplicación;
es decir, todo aquel código que no es propietario (normalmente no pertenece al desarrollador) pero que, sin
embargo, es necesario para ciertas funciones de la app (las llamadas libs).

En este punto de las dependencias se han producido diferentes cambios en la forma de introducirlas, en
función de las versiones. Es muy importante tener en cuenta que la directiva o palabra “compile” dejará de
poder usarse, o se considerará obsoleta, a partir de enero de 2019, y deberá sustituirse por “implementation”.
El resto es el identificador de la biblioteca y la versión.

Se sigue manteniendo la carga de la carpeta “libs” donde se colocarán todos los archivos *.jar que utilice la
aplicación (la extensión *.jar hace referencia a bibliotecas java).

Componentes de aplicación

Se dice que los componentes Android son entidades individuales pero que interaccionan entre sí, en
muchas ocasiones para generar una mejor experiencia de uso. Constan de 4 grupos principales: Actividades,
Servicios, Proveedores de Contenidos y Receptores de mensajes.

¡Explicamos cada uno de ellos a continuación!

Actividades
Siendo una poco generalista, y para comprender mejor la idea, cada una de las pantallas de una app tiene
por detrás una actividad. La actividad está escrita en código java y hereda de activity o variantes de ella.

Más adelante aparecerán variantes de activity, como puede ser la fragment activity, aunque esto es algo más
avanzado. Por el momento el concepto es reutilizar una misma actividad para realizar diferentes funciones
pero cargando pedazos de código más pequeños llamados fragmentos.

En esta imagen puedes ver claramente cómo con las nuevas versiones ya no extienden directamente de
“Activity” sino de “AppCompactActivty”, que no es más que una nueva clase “hija” de Activty.

Página 38 de 100
Este cambio viene ligado al uso de “Material Design” (librerías más modernas existentes para desarrollo en
Android) y a que, en muchos casos, “Activity” se considera ya obsoleta.

Este ejemplo es realmente sencillo y lo único que hace es añadirle un recurso gráfico a la actividad con el
“setContentView()”. Dentro del código para acceder a recursos se debe escribir “R.layout.activity_main”.
Más adelante se hará hincapié en estos accesos.

El acceso se realiza a través de “intents” cuyos métodos principales son “startActivity() o

startActivityforResult()”. Recuerda que los intent son métodos de comunicación entre los componentes de
las aplicaciones.

Servicios
Se trata de un componente que ejecuta tareas en segundo plano y se utiliza para realizar acciones que
se prolongaran mucho en el tiempo. No lleva asociada ninguna pantalla. En este caso, el servicio heredará
de “service” y más adelante hablaremos de ellos más extensamente, ya que son una de las herramientas
principales para el consumo de esta clase de servicios.

El acceso se realiza a través de “intents” con los métodos “startService() o bindService()”.

Proveedores de Contenido
Son los encargados de gestionar los datos compartidos de las aplicaciones. Un ejemplo típico es una base
de datos de SQLite, aunque hay un concepto claro: que se utilice un proveedor de contenidos para acceder a
una base de datos SQLite no quiere decir que todas mis aplicaciones puedan acceder, y en el propio proveedor
se indicará el tipo de acceso que se desea permitir. Hereda de la clase “ContentProvider”. Más adelante
conoceremos más detalles al respecto.

Por último es importante resaltar que todo proveedor de contenido debe disponer de una API que permita el
acceso a sus funcionalidades. El acceso a este componente es un poco especial con respecto al resto ya que
requiere la intervención de un “ContentResolver”.

Receptores de mensajes
Para entender mejor su concepto se podría tomar como ejemplo una notificación de cualquier juego o
aplicación. Es un componente especial que proporciona un aviso (normalmente a través de la barra de
estado) de lo que sucede en algunas aplicaciones aunque en ese momento se encuentre en ejecución otra app
diferente. Aquí hay que destacar que puede haber una excepción en función de la configuración de los móviles.
Normalmente no suelen tener pantalla (aunque a veces realizan pequeñas interacciones con el usuario y en
ese caso sí sería necesaria). Heredan de la clase “BroadcastReceiver".

En este caso, más que acceder al componente lo que se pretende es enviar un mensaje. Se realiza a través
de “intents” y los métodos más comunes son “sendBroadcast(), sendOrderedBroadcast() y
sendStickyBroadcast()”.

Página 39 de 100
AndroidManifest

El AndroidManifest es el documento escrito en xml donde se deben registrar todos los componentes,
permisos y características principales de la aplicación.

Revisando el manifest de la app "Hola Mundo" se puede ver que aparece la etiqueta “application”, la cual
contiene todos los componentes que pertenecerán a la aplicación y características como su icono; o bien la
activity principal, que será la primera que se ejecute al lanzar la aplicación.

La definición de un componente activity es a través de la etiqueta “activity”, pero además debe señalarse que
esta actividad será la principal. La primera que se ejecute añade un “intent-filter” indicando un “intent” con
la categoría “launcher”.

Para definir otros componentes se utilizarán las etiquetas “service, receiver y provider” respectivamente.

Página 40 de 100
Uno de los puntos importantes en un manifest son los permisos de usuario, es decir, comunicarle al usuario
qué partes del móvil se necesitan para que la aplicación se ejecute correctamente y que sea él quien autorice
su uso.

Aparte de definirlos, en este punto (normalmente pide permisos durante la instalación) también será necesario
pedirlos o confirmar que se poseen en tiempo de ejecución.

En esta imagen se puede ver el manifest de una aplicación en desarrollo donde ya se piden permisos de
acceso a internet y de estado de conexión a través de las etiquetas “uses-permission”.

Recuerda, solo se deben pedir permisos para aquellos elementos que sean necesarios para el desarrollo de la
aplicación.

Página 41 de 100
Recursos

Los recursos se podrían dividir en 4 tipos: imagen, texto, colores y estilo. Estos estarán contenidos en la
carpeta “res”.

Los recursos de imagen son imágenes, principalmente en .png aunque también se admiten otros formatos (se
utilizan mucho para fondos los llamados "9-patch") que se usan normalmente para personalizar los controles
de usuario (botones, cuadros de texto..). Se encuentran ordenados en una serie de carpetas atendiendo
principalmente a su resolución (aquí también están los iconos de aplicación). Aunque no son realmente
imágenes, las pantallas que el usuario verá también se encuentran almacenadas en estos recursos y se las
conoce por el nombre de “layouts”.

A los recursos de texto se les conoce como strings y almacenan los textos que deben aparecer en la app. Con
la combinación de diferentes archivos de strings se consigue una aplicación multilenguaje.

Los colores “colors” y los estilos “styles” están ambos relacionados con la apariencia de la app. En el
primero se definen los colores básicos que se usarán y en el segundo una serie de estilos personalizados
(customizados). Sobre recursos se profundizará más adelante en un apartado dedicados a ellos.

Por último recodar que para obtener más información se puede consultar Android Fundamentos, la
documentación oficial fuente de consulta a lo largo de esta documentación.

Página 42 de 100
Interfaz de usuario
Cuando se habla de interfaz de usuario se hace referencia a las diferentes pantallas que intervienen en
una aplicación.

A grandes rasgos se pueden diferenciar 2 partes: la propia salida por pantalla o layout (código xml) y la
parte funcional (código java). Normalmente estas interfaces están basadas en multitud de elementos, como
pueden ser cuadros de texto, botones, espacios para imágenes, etc. Todo elemento colocado en un layout
tendrá una representación en el código java y deberá ser identificado (registrado) en él para poder utilizarlo.

Estos layouts que son “la representación gráfica” de la pantalla constan normalmente de un elemento
principal llamado “view” que contiene al resto. La “view” puede ser de varios tipos y se diferencia en cómo
permite el posicionamiento dentro de ella del resto de elementos. Por ejemplo “horizontal" se situará a
la derecha del anterior, “vertical” debajo y, por ultimo, “relativa” (en las últimas versiones es sustituido por
constraint) los elementos se colocan en función de otros.
La forma más rápida de entender estos conceptos es realizando un ejemplo. Se desarrollará una aplicación
sencilla que tendrá dos únicas pantallas. En la primera figurará un texto de bienvenida y un botón que dé
acceso a la segunda. Esta será un poco más compleja y constará de texto que se irá actualizando según lo que
se escriba en otro cuadro de texto editable. Las actualizaciones se realizarán al pulsar un botón y, además,
habrá otro que finalizará la aplicación.

En primer lugar vamos a crear una nueva aplicación basándonos en los pasos explicados anteriormente, pero
en este caso, se llamará “InterfacesUsuario”. El único cambio con respecto a “HolaMundo” será el nombre
“MainActivity” por “ActividadUno”. Una vez finalizada la creación del proyecto se debe abrir el archivo “/res/
layout/activity_actividad_uno”, un xml que contiene la representación gráfica de la pantalla o los elementos que
compondrán la pantalla 1.

En este archivo se dispone de distintas formas de visualización o de trabajo:

La primera es una vista de diseño donde se tiene la apariencia final

de la pantalla y además una herramienta para el ajuste o
composición utilizada para situar adecuadamente los componentes
en la misma.

Página 43 de 100
El segundo tipo de vista es la tipo texto donde se tendrá acceso a
todos los componentes con sus propiedades.

Normalmente cuando un programador se inicia en Android la mejor opción es trabajar con la vista de diseño
y según se vaya adquiriendo experiencia pasar a la vista texto. Siguiendo las instrucciones del ejercicio
construiremos una pantalla que contenga un cuadro de texto y un botón en primer lugar.

Aprovechando que con anterioridad se ha abierto el layout de la pantalla1, se comenzará a modificar este
layout.

Página 44 de 100
En la vista de diseño se pueden identificar diferentes elementos, y arriba a la izquierda encontramos la paleta
que contiene todos los necesarios para crear las pantallas:

Texto
Contiene todos los elementos de texto tanto para mostrarlo como para recibirlo.

Botones
Contiene todos los tipos de botones disponibles para usar en la creación de pantallas.

Widgets
Son una serie de componentes con funciones muy especiales, como puede ser la barra de progreso o un
interruptor.

Layouts (disposiciones)
Por decirlo de una manera que se entienda fácilmente, son los contenedores más genéricos sobre los que se
colocan el resto de elementos. Son de diferentes tipos y en función del que se utilice variará la forma de situar
los componentes.

Containers
Son contenedores más particulares usados para realizar pantallas más personalizadas.

Google
Son unos componentes especiales necesarios, por ejemplo, para mostrar un mapa en la pantalla.

Legacy
Son diferentes componentes más antiguos heredados de versiones anteriores de las APIs de Android.

Página 45 de 100
Una vez apuntado que se dispone de diferentes componentes que se encuentran clasificados, explicaremos
qué elementos contiene la pantalla y qué se debe modificar o añadir para crear el diseño deseado. Debe
prestarse atención a la parte inferior izquierda donde aparecen indicados de forma jerárquica los diferentes
componentes de la pantalla y su grado de anidamiento (cuáles están por encima de otros o situados al
mismo nivel del contenedor principal).

En esta imagen puede apreciarse cómo el layout del que parte para crear la pantalla tiene como base o
contenedor general un “constraintlayout” que se trata de un “contenedor” que podríamos decir que sustituye
al “relativelayout” usado en versiones anteriores de la API Android.

Este contenedor es uno de los más usados, pero es un poco más complejo de utilizar. Para situar un nuevo
componente debe indicarse qué puntos de referencia se toman con respecto a dicho contenedor o
incluso respecto a otros componentes.

Al verlo de esta forma parece un poco complejo, por lo tanto, lo mejor es ir creando la pantalla y explicándola.
¡Pasa de pantalla!

Página 46 de 100
Partimos
del
contenedor
general,
que
basta
arrastrarlo
desde
la
paleta
y
soltarlo
en
esta
pantalla
azul
o blanca
(si
visualizamos
el
estado
gráfico
o
el
acabado
final)
para
usarlo
de
base
sobre
la
que
situar
el
resto
de
elementos.
A
continuación,
y
siempre
partiendo
de
la
paleta,
se
arrastra
el
siguiente
elemento
que
se
necesite,
en
este
caso

Página 47 de 100
un
texto
conocido
como
“textview”
que
será
el
equivalente
a
lo
que
otros
lenguajes
llaman
“label”.

Una vez arrastrado, lo siguiente es marcar las constraint (se deben entender como los puntos de referencia
necesarios para situar los componentes en pantalla).

Para fijarlas se debe colocar el ratón sobre cada uno de los pequeños círculos que se ven alrededor de la caja
de texto, pulsar botón izquierdo (se producirá un cambio de color) y llevar la flecha hasta el borde que se desee
tomar como referencia. Esto se repetirá con todos los puntos que se deseen marcar.

En la imagen superior se puede ver cómo el texto está centrado horizontal y verticalmente tomando como
referencia los 4 puntos disponibles.

Página 48 de 100
Una vez marcadas las referencias se utilizará el esquema básico situado en la parte superior derecha de la
pantalla para afinarlas con las dos barras desplazables que indican la posición relativa con respecto a los
laterales.

Se tienen además unos círculos alrededor de la representación de la caja de texto que indican el margen o
separación que se quiere tener con respecto a la posición indicada por las barras desplazables.

Para obtener información detallada sobre cómo crear un layout a través del layout constraint se puede
consultar el siguiente enlace Layout Constraint.

En este momento estaría colocada la caja de texto en el espacio que deseamos, pero faltaría definir su
tamaño tanto en alto como ancho. Para ello se debe recurrir a dos atributos llamados “layout_width"
y "layout_height”.

Los valores que pueden tomar estos atributos serán normalmente 3:

Wrap_content
Ajustado al contenido.

Match_constraint (o match _parent)

Página 49 de 100
Ajustado al límite del constraint o al elemento padre, como se prefiera entender.

Insertar valores en DP (80dp,100dp)

Lo que hace es indicar un tamaño fijo.

En este caso, se utilizará el ajuste a contenido (que suele utilizarse en los textview salvo en algunas
excepciones). Otros dos atributos necesarios serán el “text” donde se debe introducir el texto deseado
(también se podrá cambiar o incluir desde el código java) y, por último, es importante identificar la caja de texto
a través del campo “id”. Este debe ser único, y para ello un pequeño convenio consiste en indicar primero el
componente, a continuación el nombre de layout y, por último, el nombre de campo.

Aquí, y siguiendo el convenio, la id del campo de texto quedaría de la siguiente manera

“text_activity_actividad_uno”.

Para añadir otros atributos se pulsará sobre el texto resaltado en la parte inferior de la pantalla “view all
attributes”.

Según el enunciado inicial esta pantalla necesitará un botón que permita el paso a una segunda pantalla.
Para ello se selecciona un componente de la clase “button” y se arrastra hacia ella, volviendo a indicar las
diferentes referencias. En este momento, a parte de disponer los valores con respecto al marco o al padre,
también se pueden fijar referencias con respecto a otros componentes situados ya en la pantalla (en este caso
sería con respecto a la caja de texto).

Página 50 de 100
En esta imagen tenemos el diseño final de la pantalla y cómo se toman referencias del botón sobre el marco
general y sobre un componente situado previamente.

Una vez finalizado el diseño de la pantalla 1 se puede pasar a diseñar la pantalla 2. Para ello debe crearse un
nuevo archivo layout pulsando botón derecho sobre la carpeta layout y seleccionando “new layout resource
file”.

Página 51 de 100
Una vez seleccionado habrá que indicar el nuevo nombre (filename). En este caso, “activity_actividad_dos” y
se podrá escoger el “root element” o el marco general donde se compondrá la pantalla.

Repasando el enunciado del ejercicio, esta pantalla deberá mostrar un texto que se irá actualizando según el
que figure como entrada al pulsar un botón. Por lo tanto, deberá colocarse un “textview” donde se mostrará
el texto, un “edittext” donde se recibirá la entrada de texto y, por último, un par de botones: uno para
actualizar y otro para salir de la app.

Página 52 de 100
En esta imagen se puede apreciar el diseño final de la pantalla 2, los componentes que la forman y las
referencias de alguno de ellos.

En este punto estaría definida toda la parte gráfica de la aplicación. Ahora habría que implementar la
funcionalidad a través del código java. Destacar que en este ejemplo no será necesario introducir permisos
debido a su sencillez.

Abriremos en primer lugar la actividad 1 “ActividadUno” dentro de la carpeta Java. En ella registraremos los
componentes de la parte gráfica y, a partir de un “intent”, avanzar hacia la actividad 2.

Página 53 de 100
En esta imagen se puede comprobar cómo debemos indicar primero el layout asociado a la actividad para, a
continuación, registrar todos aquellos componentes con los que se vaya a interactuar en ella.

Para indicar qué hacer cuando se pulsa el botón se registrará un “listener” que contendrá el código con la
acción a realizar al pulsarlo; en este caso, un “intent” hacia la actividad 2.

Página 54 de 100
Por el momento no tenemos la actividad 2, por lo que no podremos implementar el “intent” hacia ella. Así
pues, el siguiente paso es crearla. Para ello partimos de la carpeta Java que contiene el código, pulsamos botón
derecho, crear “new Java Class”.

Página 55 de 100
Antes de finalizar la creación se debe indicar el nombre del archivo y la clase de la que hereda (esto último se
podría hacer más tarde añadiéndole la palabra reservada “extens” y la clase de la que heredaría).

Página 56 de 100
Una vez creada la clase lo primero será implementar el método “onCreate”. A partir de ahí, indicar la salida
por pantalla, registrar los componentes y, por último implementar los “listener” de los botones, el código que
captura el contenido del “editext” y lo muestra en el “textview” y el método “finish” que finalizará la
aplicación.

Todavía no se podrá ejecutar la aplicación, quedan dos puntos por hacer: registrar en el manifest la
actividad 2 e implementar el “intent” en la actividad 1.

Página 57 de 100
Una vez implementado todo ejecutamos la aplicación.

Inicio de la aplicación

Página 58 de 100
Cambio
de
pantalla

Página 59 de 100
Nuevo
texto

Página 60 de 100
Actualizar
texto

Página 61 de 100
Página 62 de 100
Recursos

Introducción

Una buena definición de recursos podría ser el almacén que contendrá, de una forma organizada, todas
aquellas imágenes, estilos o textos que intervendrán en la aplicación.
No se debe olvidar que los layouts también están incluidos dentro de este almacén, aunque ya se ha visto con
anterioridad que representan la parte gráfica de la pantalla (lo que ve el usuario).

Imágenes

Cuando se habla de imágenes nos referimos a todas aquellas (se admiten diferentes formatos) que pueden
intervenir en la aplicación, incluyendo los iconos. Se dispone de dos carpetas: drawable y mipmap que
funcionan prácticamente igual, pero algunas fuentes proponen las siguientes reglas:

Mipmap
Se colocarán en mipmap los iconos de aplicación y aquellas imágenes que, por tamaño o resolución, puedan
ser críticas para la aplicación.

Drawable
Se colocarán en la carpeta drawable el resto de imágenes que no cumplan ninguno de los criterios anteriores.

Como puede verse, estas definiciones son algo vagas y pueden llevar a errores, más teniendo en cuenta
que ambas carpetas funcionan prácticamente de la misma manera, permitiendo generar una serie de
subcarpetas donde situar las imágenes en diferentes resoluciones.

Por lo tanto, lo que suele realizar una gran mayoría de desarrolladores es:

Utilizar mipmap para colocar los iconos de aplicación en las diferentes resoluciones.

Utilizar drawable para los “9-patch” (imágenes especiales que se agrandan o estiran) y para colocar el resto de
imágenes con sus resoluciones correspondientes.

Con anterioridad se han mencionado las diferentes resoluciones de imágenes. Esto es debido a la gran
cantidad de dispositivos que tienen como S.O. Android. Normalmente lo que se hace es diseñar las
aplicaciones con un “diseño responsive”, buscando unos ajustes generales que se puedan adaptar al tamaño
de pantalla del usuario.

Página 63 de 100
Strings

Los “strings” son los textos a los que se hacía referencia previamente. Cuando se desea que aparezca un texto
en la aplicación la mejor solución es colocarlo en este archivo. Se encuentra ubicado dentro de la carpeta
“values”.

Este archivo string está basado en xml y contiene un identificador de texto y el propio texto como se puede
ver en la siguiente imagen:

Este archivo es la base para realizar aplicaciones multilenguaje. Normalmente el archivo “values/
strings.xml” se toma como base (por defecto) del lenguaje (depende del desarrollador, aunque lo más normal
sería tomar el inglés). Sin embargo, cuando se quiere hacer multilenguaje, debe crearse una copia de este
archivo en tantos lenguajes como se precise y realizar la traducción de los diferentes strings. Un ejemplo sería
“values-es/strings”. Debemos tener mucho cuidado porque donde se produce el cambio de nombre es en la
carpeta “values-es”, ya que aparece también una nueva.

Para más información al respecto, consultar Android multilenguaje.

Página 64 de 100
Estilos y colores

Los archivos de estilos y colores van ligados a la apariencia y están contenidos dentro de la carpeta “values”.
Como su nombre indica, la función es personalizar estilos y colores de la aplicación (son xml).

En esta imagen puede verse cómo está definido el estilo principal de la aplicación, indicando el nombre
que se le asigna y de dónde hereda las diferentes propiedades que tiene (en este caso, colores principales del
tema). Así podrían crearse estilos personalizados donde se indique el color del texto, el tamaño…

En este caso, se muestra la definición de los colores principales de la aplicación, indicando su nombre y
referencia al color. También se pueden crear colores personalizados para utilizarlos en las distintas pantallas
que vamos creando.

Acceso a los recursos

El acceso a los recursos puede realizarse normalmente desde dos puntos:

Desde los archivos xml a través de:

• “@string/nombre_texto”

• “@color/nombre_color”

Desde el propio código java a través de:

• R.drawble.nombre_imagen

• R.style.nombre_estilo

Para más detalles sobre el acceso se puede consultar Acceso a Recursos.

Página 65 de 100
Ejemplo de uso

A continuación se realizará un ejemplo de uso basándose en el ejercicio que ya tenemos, y en el que se debe
cambiar el Icono de aplicación, definir un color, un estilo y colocar adecuadamente los strings. Además, se
indicará cómo utilizar un “9-patch”.

En primer lugar se crea un nuevo proyecto replicando el código que ya tenemos, o bien podemos trabajar
sobre ese mismo. En este caso se generará un proyecto nuevo basado en el anterior sobre el que se aplicarán
los cambios.

Para cambiar el icono de la aplicación debe tenerse en cuenta que en Android disponen actualmente de un
icono con aspecto rectangular (más habitual) y otro round (o redondeado, añadido con las últimas versiones
de la API), por lo que deberán cambiarse ambos.

Para diseñar un icono se deben tener en cuenta las siguientes consideraciones relacionadas con la densidad
de pantalla:

Tipo de Densidad Descripción Factor Escala Densidad Aproximada

MDPI Media densidad, base para el diseño x1 160
HDPI Alta densidad x 1,5 240
XHDPI Extra alta densidad x2 320
XXHDPI Extra extra alta densidad x3 480
XXXHDPI Extra extra extra alta densidad x4 640

La base del diseño actual es MDPI (con anterioridad se utilizaba LDPI).

En este caso crearemos dos iconos, uno rectangular y otro redondo de aproximadamente 48x48. Aplicando
los factores de escala se podrá obtener el resto de imágenes que serán necesarias para adaptar el icono a
multi-pantalla.

En función de los diseñadores con los que se colabore tenemos varias formas de trabajo, aunque una de las
más utilizadas consiste en proporcionar las imágenes de más densidad para ir reduciéndolas posteriormente
según los factores de escala.

Esta forma de trabajar para crear los iconos es también propia del resto de imágenes para la aplicación: se
diseñan sobre MDPI y a partir de ahí se calcula el tamaño para el resto de densidades de pantalla.

Para diseñar estas imágenes puede utilizarse una herramienta de software libre llamada Inkscape.

Una vez acabados los diseños se toman todas las imágenes de los
iconos y se copian en la carpeta “mipmap” del proyecto respetando
sus densidades.

Página 66 de 100
A continuación podrá verse cómo aparecen dos carpetas nuevas
dentro de “mipmap” con los nombres de las imágenes copiadas y
todas las densidades disponibles. Hasta este punto el procedimiento
es el mismo para otros tipos de imágenes contenidas en “drawables”.

Página 67 de 100
En este momento ya se puede cambiar el icono. Para ello hay que
dirigirse al “AndroidManifest” y cambiar los recursos (en este caso,
de imagen) asignados a las propiedades “android:icon” y
“android:roundIcon”.

A continuación, puedes ver el resultado:

Página 68 de 100
Página 69 de 100
Lo siguiente que pedía el enunciado era crear un color y un estilo.

Para ello abrimos el archivo “colors.xml”, definimos un nuevo color

y, a continuación, realizamos un proceso similar en el archivo
“styles.xml”. Aprovechando que se va a crear un estilo
nuevo modificaremos el que trae por defecto de la aplicación para
eliminar las cabeceras (se indica con no actionbar).

Aprovechando este color nuevo se incluirá como parte del nuevo

estilo. Este solamente indicará tamaño y color del texto.

Por el momento se ha generado un nuevo estilo y color, pero no se

ha aplicado. Para ello abrimos los layouts de las diferentes pantallas
y asignamos este nuevo estilo a sus campos de texto en la propiedad
“textAppearance”.

Página 70 de 100
En algunos momentos puede que no se vean bien los cambios. Para arreglar esto lo mejor es realizar un “Clean
Project” desde el menú “Build”.

Con esto se habrán aplicado los estilos a las etiquetas de texto pero todavía quedaría insertar estos en el
archivo “strings.xml” y luego referenciarlos correctamente.

Una vez abierto el archivo strings solo se debe indicar un identificador para el texto. En este caso, se dispone
de 2 textos de bienvenida y el hint para indicar dónde se debe escribir.

Con esto todavía no se habría finalizado. Ahora es necesario cambiar los campos de texto que se escribieron
anteriormente por la referencia a estos a través del archivo.

Página 71 de 100
Página 72 de 100
El último punto interesante del ejemplo es el uso de los "9-patch", que no son más que unas imágenes de
tamaño variable que se pueden estirar según se necesite. Normalmente se sitúan en la carpeta “drawable” y
son muy usadas como fondos de tamaño variables, por ejemplo en cuadros de texto, diálogos de alertas… En
este caso la fijaremos como fondo de las actividades.

Página 73 de 100
Conviene estar muy pendiente del nombre, ya que no aparecerá la extensión “9-patch” a la hora de
seleccionar la imagen. Una de las formas de identificarlos es a través de unas pequeñas líneas negras que
aparecen en los laterales de la imagen y que señalan qué partes se repetirán para hacer el efecto de
“estiramiento”.

Página 74 de 100
Almacenamiento

Introducción

El almacenamiento es un punto importante para un desarrollador, ya que será el lugar donde se guarden
todos los datos necesarios para la aplicación. Debe recordarse que en desarrollo móvil solo deben guardarse
aquellos datos esenciales debido a las restricciones de espacio. Normalmente, cuando se vaya a trabajar con
grandes cantidades de datos, la mejor solución es utilizar un modelo cliente/servidor.

Android dispone de diferentes opciones de almacenamiento:

Interno
Sirve para guardar datos privados de la app en la propia memoria interna del dispositivo.

Externo
Almacenará datos públicos en el almacenamiento externo compartido.

Preferencias (sharedPreferences)
Se trata un diccionario clave-valor donde se permiten almacenar datos primitivos.

Bases de datos SQLite

Se trata de una base de datos privada que permite guardar datos con cierta estructura (está considerada una
base de datos relacional).

Según la documentación oficial se admite como opción el sistema el almacenamiento de datos a través de
internet (servidor), con lo que se estaría usando un modelo cliente/servidor.

Este apartado de almacenamiento está basado en la documentación oficial de Android Developers Storage.

Página 75 de 100
Almacenamiento Interno

Permite guardar archivos directamente en el dispositivo. Habitualmente estos se almacenan de forma

privada y solo la aplicación que los crea puede acceder a ellos. Es decir, ninguna otra ni el usuario tendrán este
acceso. Estos archivos desaparecen al desinstalar la aplicación.

Creación de un archivo
Para crear un archivo debe recurrirse al método openFileOutput() y el procedimiento sería el siguiente:

• Apertura del fichero de salida mediante el método openFileOutput() que devolverá un objeto de tipo
FileOutputStream. Se debe controlar el modo de apertura, por defecto private pero también podría ser
append. Anteriormente existían otros modos pero con las nuevas versiones de la API desaparecieron.

• Se escriben los datos deseados.

• Se cierra el fichero.

Lectura de archivo
Para leer un archivo se utilizará el método openFileInput() y el procedimiento sería el siguiente:

• Apertura del archivo con el método openFileInput() que devolverá un objeto de tipo FileInputStream.

• Se leen los datos.

• Se cierra el archivo.

Página 76 de 100
En el ejemplo anterior del apartado "Ejemplo de uso" se han realizado unos pequeños cambios incluyendo 3
métodos para trabajar con almacenamiento interno. Los dos primeros son la forma estándar de acceso y el
tercero es una modificación para el caso de un archivo de texto.

Dentro del almacenamiento interno también se puede utilizar el guardado en la caché a través de métodos
como el getCacheDir().

Almacenamiento Externo

Se trata de almacenar archivos en el directorio externo compartido que normalmente será la SDcard.

En versiones anteriores se permitía acceso directo a la tarjeta externa pero en las actuales su uso debe
gestionarse a través de un proveedor de contenido “MediaStore”.

Se necesita solicitar los permisos de lectura y escritura READ_EXTERNAL_STORAGE y

WRITE_EXTERNAL_STORAGE, aunque hay algunas excepciones en las que no sería necesario (archivos privados
de la aplicación). Al necesitar estos permisos también se debe comprobar que están permitidos en tiempo
de ejecución (importante puesto que si no es así, no funcionará).

Página 77 de 100
Para poder trabajar con este tipo de almacenamiento en primer lugar se debe comprobar si realmente existe
almacenamiento externo. Para ello se utilizará el método getExternalStorage.

Una vez obtenido el resultado, que deberá ser positivo para poder continuar, se necesita conseguir la
ruta de acceso. En caso de querer utilizar el almacenamiento público se debe utilizar el método
getExternalStoragePublicDirectory() más el tipo de directorio (DIRECTORY_MUSIC, DIRECTORY_PICTURES,
DIRECTORY_RINGTONES…).

En el siguiente ejemplo se puede ver cómo se intenta acceder a un álbum del directorio de imágenes.

Para poder guardar datos privados de una app en este espacio compartido se debe utilizar el método
getExternalFilesDIr(). La forma de acceso es muy similar al método anterior. Es importante destacar que,
en función de la versión de la API, se permitirá un mayor o menor control de la SDcard, de forma que en
versiones por debajo de la 4.3 solo se permitía el acceso a una especie de partición interna que se generaba,
pero no a la propia tarjeta.

También se pueden guardar datos en una cache externa a través del método getExternalCacheDIr().

Página 78 de 100
Shared Preferences

Se podría entender SharedPreferences (preferencias compartidas) como un gran diccionario (clave-valor)

donde guardar tipos de datos primitivos: booleanos, enteros, decimales… No se debe confundir en ningún
momento con las preferencias del usuario que se guardan de otras formas.

Existen dos métodos principales:

getSharedPreferences()
Cuando pueden existir varios archivos de preferencias para una aplicación, es necesario indicar el nombre del
archivo para acceder.

getPreferences()
Cuando existe un solo archivo de preferencias para toda la aplicación.

Como consejo, gran parte de los desarrolladores utilizan siempre el método getSharedPreferences para
trabajar con las preferencias.

Se pueden destacar dos acciones principales: guardar y cargar valores. La forma básica de trabajar con las
preferencias será la siguiente:

• Crear o recuperar el elemento "preferencia" a través del método SharedPreferences.

• Crear una instancia del editor o recuperarla con SharedPreferences.editor. Si se están guardando
datos se realizarán una serie de comandos puts, seleccionando el valor adecuado en función del tipo
de primitiva. En el caso de estar obteniendo valores el comando será gets, seleccionando también
el adecuado en función de la primitiva.

• Por último, en caso de trabajar con valores, se debe terminar guardando los cambios mediante un
commit del editor.
Realizaremos un pequeño ejemplo en el que se guardarán varios valores de preferencias de una actividad 1 y
se tendrán que recuperar en la actividad 2. El nombre de este proyecto será PreferenciasyBD.

Página 79 de 100
Una vez creado el nuevo proyecto e implementadas las funcionalidades, al ejecutar la aplicación debería
aparecer un mensaje “Actividad Uno” y un botón de “ir A” (en este se utiliza otra variante de asignar
funcionalidad a los botones).

Página 80 de 100
Tras pulsar el botón se irá a la actividad 2 donde deberá aparecer por pantalla un mensaje unión de los datos
guardados en la Actividad Uno.

Página 81 de 100
Base de Datos SQLite

Cuando se desea utilizar una base de datos en una aplicación es necesario conocer que debe tener un nombre
único para toda la app, no pueden existir 2 con el mismo nombre. Por otro lado, la ubicación de la base de
datos será siempre la misma: /DATA/data/nombre_aplicacion/databases/ARCHIVO_BASE_DE_DATOS.

Para poder trabajar con la base de datos será necesario crear una nueva clase que herede de
SQLiteOpenHelper e implementar una serie de métodos:

onCreate(SQLIteDatabase)
Donde se define e inicializa la base de datos.

onUpgrade(SQLiteDatabase,int,int)
La forma en que se debe actualizar la base de datos.

OnOpen(SQLiteDatabase)
Se encarga de abrir la base de datos o crearla en el caso de que no exista.

Además se suelen implementar una serie de métodos para permitir un mejor acceso a la base de datos
(mínimo métodos CRUD). Cuando se realizan consultas se obtendrá el resultado a través del “Cursor” que
proporciona un puntero a los datos devueltos para poder acceder a ellos de forma más sencilla.

Estos son una serie de pasos para crear una clase que genere y controle la base de datos:

• Creación de una clase "adaptador" en cuyo interior deberá encontrarse una clase estática que extenderá
de SQLiteOpenHelper.

• Crear el constructor de la clase principal (adaptador).

• Crear el constructor de la clase interior (estática).

• Sobrescribir los métodos onCreate() y onUpGrade().

• Crear el método abrir.

• Crear las operaciones.

Operación Método
Consulta Query()
Inserción Insert()
Actualización Update()
Borrado Delete()

Realizaremos un ejemplo sobre el proyecto PreferenciasyBD creando una base de datos con una tabla sencilla
e implementado las operaciones CRUD. Crearemos un tabla de empleados que contenga nombre, apellido,
DNI y teléfono.

En cuanto a las funciones, lo normal sería implementar un listado de todos los empleados, una búsqueda por
id, opciones para insertar uno nuevo, actualizar sus datos y eliminarlos.

En este caso se trabajará sobre la actividad 1 del proyecto. Desde un nuevo botón se podrá acceder al listado
y ver cómo aparecen los empleados en el textview.

Página 82 de 100
Para ver las implementaciones y comentarios puedes consultar el archivo “MiAdaptadorSqlite” donde hay un
ejemplo de la base de datos realizado en detalle (proyecto PreferenciasyBD).

Página 83 de 100
Sensores
Actualmente todos los dispositivos Android llevan incorporado algún tipo de sensor de alta precisión que envía
información sin procesar relativa a la posición del teléfono con respecto a su entorno.

Aunque no todos los dispositivos suelen tener todos los sensores, los más usuales son acelerómetro y
magnetómetro.

Los sensores se engloban en diferentes categorías, y es importante conocer que puede haber de hardware
(existe dispositivo sensor) y basados en software. La clasificación general sería la siguiente:

Movimiento
Miden las fuerzas de aceleración y rotación a las que se somete el dispositivo (acelerómetro, gravedad,
giroscopio).

Ambiental
Condiciones de humedad y temperatura (barómetros, fotómetros…).

Posición
Miden la posición física del dispositivo (orientación, magnetómetros…).

Todas las interacciones con los sensores se realizarán a través del “Sensor Framework”, y las interfaces que
proporcionan son:

SensorManager
Dispone de diferentes métodos de acceso para los diferentes sensores y permite realizar comprobaciones de
la precisión.

Sensor
Acceso a única clase de sensor.

SensorEvent
Proporciona información sobre un evento específico del sensor.

SensorEventListener
Permite realizar ciertas acciones cuando se detectan cambios en el sensor.

Normalmente el trabajo de los sensores se basa en ver si están disponibles en el dispositivo para funciones
que luego los usarán y en monitorizar eventos para realizar una serie de acciones según los que se produzcan.
Un uso típico es en videojuegos que aprovechan la inclinación del dispositivo.

Con el fin de entender un poco mejor el trabajo con sensores, haremos un pequeño ejemplo utilizando el
acelerómetro en el que habrá un botón de start/stop y 3 cuadros de texto mostrando la variación del sensor
según el movimiento.

El proyecto es PruebaSensores.

Página 84 de 100
En primer lugar, se debe hacer que la actividad implemente un SensorEventListener. Para ello tenemos dos
formas: a través de una clase o directamente en la propia actividad (será la elección para el ejemplo).

Por otro lado, se debe instanciar un SensorManager para obtener

acceso a los sensores.

Por último, implementar onSensorChanged que se ejecuta cada vez

que se produce una variación en el sensor y onAccuracyCahnged.

En este ejemplo se trabajará con el primero de ellos para actualizar los datos de aceleración en función del
movimiento del teléfono.

Hay 2 momentos importantes que son el registro y la anulación del registro del listener, ya que es el
responsable de estar pendiente de los cambios del sensor.

Normalmente el registro se realiza en el onResume de la actividad y la anulación en el onPause o incluso

onStop también; siempre y cuando se quiera que el listener esté disponible al comenzar a usar la aplicación.

Página 85 de 100
Para realizar el ejemplo se debe crear un layout con 3 cuadros de texto que mostrarán la variación del
sensor y un botón que, haciendo una excepción, se utilizará para registrar y anular el listener (proyecto
PruebaSensores).

Para más información sobre sensores se puede visitar Android Sensores.

Servicios Web

Introducción

Los servicios web también podrían llamarse algo así como “Conectándonos a internet”. Hay multitud de
aplicaciones que funcionan de forma local en los dispositivos pero la potencia real viene del uso de la
arquitectura cliente/servidor.

Normalmente una aplicación se conectará a internet para recibir una serie de datos en diferentes formatos y la
mayoría de estas conexiones se realizan a través del protocolo http utilizando los clientes nativos de Android
como son: HttpUrlConnection y apache HttpClient.

La conexión a internet conlleva una serie de pasos:

• Conectarse al URI.

• Recibir los datos.

• Procesar los datos recibidos.

Android funciona con un hilo principal llamado UiThread que no debe bloquearse con operaciones que lleven
mucho tiempo, por lo que la conexión y procesado de datos se ejecutan en segundo plano a través de una
serie de herramientas:

Página 86 de 100
Hilos

Reciben el nombre de Worker thread y son usados para procesos en segundo plano. Como desde ellos nunca
se podrá acceder a los elementos, se usarán los handler para devolver los resultados al hilo principal.

De esta forma habrá un hilo que realizará toda la conexión con el servidor y la descarga de datos y un
handler encargado de su manipulación y de la actualización de la interfaz gráfica.

Página 87 de 100
Página 88 de 100
Para poder realizar correctamente las conexiones se muestra en el ejemplo, a parte de los propios permisos
del androidManifest, la forma de pedirlos en tiempo de ejecución, necesario en las últimas versiones de la
API .

AsyncTask

AsyncTask es una de las formas más comunes para el trabajo en segundo plano y permite acceder a la
interfaz desde dos de sus métodos: antes de que comience el trabajo en segundo plano y después.

Además permite actualizar, por ejemplo, una barra de estado.

Página 89 de 100
Se implementa como una nueva clase que puede encontrarse, o no, dentro de una principal. Debe extender de
AsyncTask y el contenido entre símbolos <> controla los tipos de datos de <entrada, actualización,salida>.

Obligatoriamente implementa el método doInBackground donde se realizará todo el trabajo de descarga y

tratamiento de los datos.

También resulta útil implementar los métodos PreExecute y PostExecute.

El primero permite acceder a la interfaz gráfica antes de comenzar la descarga y el segundo después, cuando
los datos han sido procesados.

PreExecute

PostExecute

Página 90 de 100
Una vez creada la clase se ejecutará a partir del comando execute.

Página 91 de 100
Servicio

El servicio es utilizado principalmente para tareas en segundo plano que van a llevar mucho tiempo ejecutar,
y consta de dos partes principales:

Clase servicio

BroadcastReceiver

Página 92 de 100
El BroadcastReceiver debe implementarse en la actividad para tratar los datos recibidos y actualizar desde él
la interfaz gráfica.

Página 93 de 100
El funcionamiento es el siguiente: desde un punto de la aplicación se iniciará el servicio y, cuando este
haya acabado la tarea asignada, enviará un intent con los datos al BroadcastReceiver, que comenzará el
tratamiento y actualización (en algunos casos pueden tratarse los datos desde el propio servicio).

El BroadcastReceiver debe registrarse y anular este registro cuando sea necesario, normalmente con los
métodos onResume y onPasuse de la actividad (en el ejemplo se han asociado estas acciones a un botón ya
que era una implementación más acorde a la funcionalidad que se deseaba mostrar).

Recuerda que, para que funcione, el servicio debe registrarse en el manifest como componente de la
aplicación.

Página 94 de 100
Ejemplo de Aplicación

Para clarificar un poco más este apartado de servicios web que será muy importante en el desarrollo de las
aplicaciones, se plantea realizar una aplicación que consuma datos de una API gratuita de Star Wars.

La idea es la siguiente: se dispone de un interfaz gráfico con 6 cuadros de texto (textview): 3 actuarán
como etiquetas de nombre, modelo y clase y los otros 3 variarán mostrando el contenido según la nave
seleccionada. En esta misma pantalla habrá 3 botones en la parte inferior:

Hilos
Ejecuta una consulta para extraer la información de una nave específica usando hilos y muestra su resultado
en pantalla.

Página 95 de 100
AsyncTask
Ejecuta
un
consulta
para
extraer
información
de
otra
nave
y
la
muestra
por
pantalla
a
través
de
la
implementación
de
una
clase
asyncTask.

Página 96 de 100
Página 97 de 100
Servicio
Ejecuta un consulta para recibir información de otra nave distinta de las dos anteriores y mostrar su resultado
por pantalla. En este caso, se deben implementar todos los elementos necesarios para realizarlo mediante un
servicio.

Página 98 de 100
La
solución
se
encuentra
en
el
proyecto
TrabajoSegundoPlano
donde
se
explica
mediante
comentarios
en
el
código
cada
una
de
las
partes.

También
se
muestra
cómo
parsear
un
string
json
de
forma
sencilla
a
través
de
la
librería
GSON
de
Google.

Página 99 de 100
Resumen
En esta unidad se han ido tratando los conceptos básicos para iniciarse en la programación Android. Se ha
comenzado por características básicas del S.O. para ir abriendo paso hacia las herramientas de programación,
en este caso, el entorno oficial Android Studio.

A continuación, se ha dado un pequeño giro para dirigirse hacia la primera aplicación android (HolaMundo)
y, a través de ella, aprender a usar el emulador y las piezas fundamentales de una aplicación Android.

Luego se ha continuado con el diseño de interfaces de usuario (pantallas) y el uso de recursos que abren la
puerta hacia la personalización de las pantallas de usuario a través de imágenes o temas.

En los últimos puntos de la unidad se han tratado nociones muy importantes como dónde guardar los datos
de las aplicaciones (almacenamiento), las formas diferentes de consumir servicios web y, por supuesto, el uso
de los sensores del dispositivo, algo muy necesario en el mundo de los videojuegos por ejemplo.

Página 100 de 100