Diseño y publicación de

una aplicación Android

 Índice de contenidos
Introducción............................................................................................................................................................... 3
Introducción ..................................................................................................................................................... 3
Objetivos........................................................................................................................................................... 3
Una aplicación completa.......................................................................................................................................... 3
Introducción ..................................................................................................................................................... 3
Estudio del problema ...................................................................................................................................... 4
Pantalla de carga ............................................................................................................................................. 6
Pantalla de menú........................................................................................................................................... 11
Pantalla de agradecimientos........................................................................................................................ 16
Pantalla de clasificación ................................................................................................................................ 18
Pantalla de preguntas ................................................................................................................................... 25
Interfaz gráfica...................................................................................................................................... 25
Preguntas y puntuación ...................................................................................................................... 31
Publicar en Google Play.......................................................................................................................................... 43
Introducción ................................................................................................................................................... 43
Preparando la aplicación .............................................................................................................................. 44
Cuenta de desarrollo y publicación............................................................................................................. 49
Resumen .................................................................................................................................................................. 55

Página 2 de 55
Introducción

Introducción

Esta última unidad está diseñada como una pequeña introducción a lo que supone desarrollar aplicaciones
Android actualmente.

Se comenzará tratando diferentes apartados del desarrollo de una aplicación (interfaces, imágenes, código…)
tomando como ejemplo una propuesta específica.

En la segunda parte del tema se explicarán los pasos necesarios para publicar una aplicación en Google Play.

Objetivos

Los objetivos de esta unidad son:

• Desarrollar una aplicación completa analizando cada una de sus pantallas.

• Configurar una nueva cuenta de desarrollador en Google Play.

• Publicar la aplicación en la tienda oficial.

Una aplicación completa

Introducción

Este será solo un ejemplo de la multitud de aplicaciones que se pueden realizar en Android. Se ha buscado
implementar varios de los temas explicados en capítulos anteriores, además de una serie de controladores
de cada vez mayor uso.

En este caso, la idea es realizar una pequeña aplicación que nos permita mostrar una serie de preguntas tipo
trivial, responderlas y, si se desea, guardar la puntuación obtenida en una base de datos.

Las preguntas se obtendrán de la API Open Trivia DB cuyo único inconveniente es que solo están disponibles
en inglés, pero para conocer el funcionamiento será suficiente. Debido a esto no tiene sentido plantearse la
opción de realizar una aplicación multilenguaje (en otras circunstancias sería lo más normal).

Página 3 de 55
Estudio del problema

Ahora viene la parte más interesante. ¿Cómo se comienza a desarrollar una aplicación?

Lo primero de todo es hacer un pequeño esquema indicando sus funciones básicas:

Debe mostrar una serie de preguntas.

Debe permitir responder preguntas.

Tiene que ser fácilmente identificable que se haya acertado o no.

Se debe poder guardar y acumular la puntuación.

Las preguntas deberían tener diferentes puntuaciones (dificultad).

Debe poder mostrar una clasificación.

Como se puede ver, son una serie de ideas sobre los puntos que se está pensando desarrollar.

A continuación, viene la búsqueda de información y, en este caso, de una API que pueda satisfacer nuestras
necesidades.

Una vez concluido este brainstorming y buscado si hay APIs disponibles, arranca una parte quizás más
creativa (normalmente la realiza el departamento de arte, aunque no siempre) en la cual se decide cómo
estructurar la aplicación, las pantallas que la compondrán y qué funciones realizará cada una:

Pantalla de carga
Generar un aspecto más formal, simulando una carga.

Pantalla de menú
Un menú para moverse por las funciones principales de la aplicación.

Pantalla de agradecimientos
En este caso, para reconocer y hacer mención a las páginas de recursos gratuitos y a la API de la que se
obtienen las preguntas.

Pantalla de clasificación

Página 4 de 55
Muestra de forma ordenada las puntuaciones obtenidas y el jugador que las obtuvo.

Pantalla de preguntas
Quizá la más compleja, ya que debe mostrar las preguntas por pantalla, implementar los diálogos para permitir
responder y el guardado de puntuación y jugador.

En este punto suele ser un buen momento para contar con un diseñador gráfico que se encargue de la parte
visual de las pantallas y la iconografía de la aplicación. Con esto no se pretender decir que un desarrollador
no pueda diseñar iconografía y pantallas, sino que, por regla general, no generarán el mismo impacto en el
público objetivo que si son hechas por un profesional.

Aunque pueda parecer una inversión alta en algunos momentos, es la mejor opción para conseguir pantallas
muy vistosas, puesto que es importante no olvidar que una aplicación hay que venderla tanto visual como
funcionalmente.

Por último, una vez recibidos los diseños y el esquema de las pantallas es cuando comienza el trabajo de
programación.

Página 5 de 55
Pantalla de carga

Página 6 de 55
Realiza sobre todo una función estética, por lo que podría prescindirse de ella y no causaría ningún tipo de
disfunción en la aplicación. Es muy parecida a la que se realizó en el apartado Widgets del tema 2.

Gráficamente está formada por un ImageView y un ProgressBar.Horizontal. Este último deberá llevar asociado
un xml para indicar el formato de la barra y su progreso.

En este caso se ha definido una serie de colores, estilos y strings en la carpeta Resource para facilitar las
Página 7 de 55
tareas.
En cuanto a la activity contendrá un método con el que simula una
descarga y actualiza el progreso que, al finalizar, dará paso a la
“Pantalla Menú”.

La diferencia con la actividad anterior es que, en este caso, la

descarga comenzará al cargar la activity y no necesitará interactuar
para nada con el usuario.

Página 8 de 55
Página 9 de 55
Una vez implementado todo se debería obtener un resultado parecido al siguiente:

Página 10 de 55
Pantalla de menú

Desde esta pantalla se puede acceder a las funciones principales de la aplicación y además, es la encargada
de crear sus SharedPreferences.

La interfaz gráfica constará de un TextView que únicamente muestra el texto “Menú” y una serie de botones
que darán acceso al resto de funciones.

Estos botones se personalizan utilizando selectores xml para, cambiando la imagen de fondo, simular la
pulsación; además de una clase Java que hereda de Button y donde se configuran sus propiedades.

Página 11 de 55
Página 12 de 55
En cuanto a las funciones que implementa la activity está la creación de SharedPreferences a través de un
método que se ejecuta al inicializarse.

Además, deben crearse los botones que dan acceso al resto de

funcionalidades utilizando intents hacia las diferentes activities que
las implementan.

Es importante recordar que todas estas activities que mencionamos

deben estar registradas en el AndroidManifest.

Página 13 de 55
Página 14 de 55
Una vez implementado todo, el aspecto en pantalla debería ser similar al de la imagen:

Página 15 de 55
Pantalla de agradecimientos

La de agradecimientos se trata quizá de la activity más sencilla de toda la aplicación. Simplemente muestra un
pantalla donde se dan las gracias a las diferentes fuentes de las que se ha obtenido información, como pueden
ser FlatIcon para iconografía y Open Trivia DB para las preguntas.

El aspecto gráfico consta de dos TextView:

• Uno de ellos para mostrar el título de la activity, en este caso, “Agradecimientos”.

• El otro para mostrar un texto contenido en el archivo strings en el que se hace referencia y reconoce las
fuentes mencionadas.

Tenemos el código en la siguiente pantalla.

Strings

Página 16 de 55
onCreate
Solo aparece el método básico onCreate que es el encargado de registrar la interfaz gráfica y mostrarla por
pantalla.

Página 17 de 55
Pantalla de clasificación

En la pantalla de clasificación se accede a la base de datos para listar de forma ordenada (orden descendente)
las puntuaciones de los diferentes jugadores que han decidido guardarlas.

La interfaz gráfica contiene un par de TextView para mostrar el título de las columnas y un ListView, uno de
los controladores más antiguos utilizados para mostrar una lista de elementos. Además, tiene opciones para
reconocer eventos de pulsación sobre ellos (aunque en este caso, no se utilizarán).

Página 18 de 55
Esto en cuanto a la interfaz principal de la activity, sin embargo, en este ejemplo será necesario también una
segunda interfaz conocida normalmente como "adaptador" que muestre el contenido gráfico de la celda del
ListView.

Página 19 de 55
Para implementar un ListView correctamente, a parte de la interfaz gráfica propia de la celda, es necesario
manejar también una clase Java que extenderá de un ArrayAdapter (en este caso de la clase modelo jugador).

Aquí se realizará la operación de "inflado" de la vista y asignación de la interfaz gráfica de la celda, así como el
registro de los elementos gráficos y su inicialización con los datos que recibe.

Antes de poder comenzar a desarrollar la activity es necesario implementar el adaptador de SQLite para tener
acceso a la base de datos. Los primeros pasos son, por orden, los siguientes:

Constantes
Normalmente se comienza declarando una serie de constantes que representan los nombres de tablas y
columnas.

Inner class

Página 20 de 55
A continuación, se crea una nueva inner class que extenderá de SQLiteOpenHelper y sobre la que se
implementarán los métodos onCreate y onUpgrade.

En este caso, también se aprovecha para generar un par de métodos que inicialicen la base de datos con
algunos valores por defecto.

Apertura y cierre
Una vez creados estos métodos se pasa a implementar los de apertura y cierre de la base de datos.

Página 21 de 55
Constructor
Terminados los pasos anteriores se dispone ya de todos los métodos necesarios para generar un constructor
adecuado.

Manejo BBDD
Por último, se deben generar los métodos necesarios para manejar la base de datos. Normalmente serían
todos los CRUD pero en este caso solo se implementarán los que se necesitan, como el listado de las
clasificaciones y la inserción de un nuevo jugador y puntuación.

Página 22 de 55
Ahora es el momento de centrarse en la activity.

Debe implementarse el método onDestroy desde el cual se cerrará la base de datos y el onCreate en el que,
aparte de registrar los elementos gráficos, deberá llamarse al método que obtiene el listado de puntuaciones.
De esta manera podrán enviarse los resultados al adaptador del ListView para mostrarlos por pantalla.

Método onDestroy

Método onCreate

Página 23 de 55
El resultado en ejecución debería ser algo parecido al siguiente:

Página 24 de 55
 Pantalla de preguntas

Interfaz gráfica

Esta pantalla quizá sea la más complicada que haremos en el curso. Deberá realizar diferentes funciones:

• Mostrar preguntas y puntuaciones.

• Reconocer el evento de pulsación prolongada y mostrar un diálogo para responder.

• Actualizar la puntuación en pantalla y la corrección de la pregunta.

• Comprobar si se han respondido todas las preguntas para guardar la puntuación.

Además, se aprovechará esta pantalla para introducir un nuevo controlador conocido como RecyclerView que
normalmente se utiliza para mostrar un listado. Su uso está aumentando desde hace algunos años.

En este caso, la interfaz gráfica será un poco particular, ya que se necesitan cuatro diferentes para realizar
todas las funciones:

Interfaz General
Contendrá tres TextView para indicar:

• Título de la activity.

• Etiqueta "Puntuación".

• Puntuación que está obteniendo el jugador.

Además, un RecyclerView donde se mostrarán las peguntas.

Página 25 de 55
Adaptador
Celda
Se
trata
de
otra
interfaz
compuesta
por:

• Un
ImageView
que
indica
si
la
pregunta
se
ha
respondido
correctamente
o
no.

• El
texto
de
la
pregunta
en
un TextView.

Página 26 de 55
Dialog
Pregunta
Se
trata
de
un
diálogo
que
contiene:

• Un
TextView
donde
se
mostrará
la
pregunta.

• Un
RadioGroup
con
hasta
4 RadioButtons
con
las
diferentes
respuestas.

• Un
Button
que
servirá
para
lanzar
la
comprobación
de
la
respuesta.

Página 27 de 55
Dialog
Guardar
Puntuaciones
Otro
diálogo
compuesto
por:

• Un
EditText
para
recoger
el
nombre
del
jugador.

• Un
TextView
para
mostrar
la
pregunta
“¿Desea
guardar?"

• Dos Buttons
para
confirmar
o
denegar
el
guardado.

Página 28 de 55
Página 29 de 55
Una
vez
definidas
las
diferentes
interfaces
lo
más
interesante
es
ir
recorriendo
las
funcionalidades
e
indicando
en
cada
una
qué
se
necesita
implementar.

Página 30 de 55
Preguntas y puntuación

Cargar preferencias

Para mostrar la puntuación se crea un método que permite el acceso a SharedPreferences, donde se guardan
estos resultados; y desde el método onCreate se actualiza sucesivamente la interfaz con su valor
correspondiente al responder correctamente.

Mostrar preguntas

Mostrar las preguntas es algo un poco más complejo, ya que antes de poder descargarlas se necesitará crear
un adaptador para el RecyclerView que registre los elementos de la vista e implemente también el método
listener para reconocer eventos onCLick o longClick sobre un componente de la lista.

Para ello debe crearse una nueva clase Java que extienda
de RecyclerView.Adapter, contenga una inner class que será la propia
vista, y herede de RecyclerView.ViewHolder.

Además de contener el registro de sus elementos deberá implementarse también el OnLongClickListener para
capturar los eventos de pulsación prolongada sobre ellos.

Página 31 de 55
En la clase principal deberá figurar su constructor.

También debe implementarse el método onBindViewHolder que

actualiza los datos de la interfaz, el getItemCount que devuelve el
número de elementos de la lista y, por último, el
setOnItemClickListener que recoge los eventos sobre el RecyclerView y
su interfaz para proporcionarle acceso.

Página 32 de 55
Descarga y parseo de datos

Ahora es el momento de preparar el método necesario para realizar la descarga y el parseo de los datos. Para
esto último se utilizarán dos clases:

• Una que los recibe tal cual de la API a través de la biblioteca volley.

• Otra que tiene unos campos extra que facilita la comprobación posterior de las respuestas mediante la
biblioteca gson.

Tanto Volley como gson deberán incluirse en el gradle.

El método encargado de realizar la descarga es muy similar al usado en el ejercicio de "IntroduccionVolley”;

solo cambia la forma de parsear, ya que una vez introducidos los datos en una clase vuelven a pasarse a
otra que permita un mejor trabajo. Además, hay dos particularidades:

Página 33 de 55
 La actualización de un flag de preguntas recibidas.

La notificación de los cambios al adaptador del RecyclerView para que se actualice.

Página 34 de 55
Por último, para poder realizar las preguntas será necesaria la comprobación de permisos (en este caso,
Internet) en el método onCreate, además de registrar los elementos gráficos. Para descargarlas deberá
determinarse antes que no han sido almacenadas previamente y que, además, no se ha finalizado el test.

Por otro lado, debe instanciarse el adaptador para el RecyclerView.

Página 35 de 55
El resultado que se obtiene al ejecutar la aplicación debe ser similar al siguiente:

Página 36 de 55
Reconocer el evento pulsación prolongada y mostrar el diálogo para responder

En esta ocasión el reconocimiento del evento está implementado y no será necesario. Por lo tanto, lo único
que quedaría sería asociar el listener al adaptador e indicar en qué situaciones se tomaría la respuesta como
contestada y en cuáles se permite lanzar el método que abre el diálogo para responder y comprobar la
respuesta.

La asociación del listener se realiza en el método onCreate de la activity.

Actualizar la puntuación de pantalla y la corrección de la pregunta

Para realizar esta acción se dispone de un método que hace aparecer un diálogo por pantalla indicando la
pregunta y las diferentes opciones de respuesta.

Actualizar la puntuación de pantalla y la corrección de la pregunta

Cuando un usuario está seguro de su respuesta pulsa el botón inferior derecho para comprobarla y, en

Página 37 de 55
El resultado de la ejecución debe parecerse a:

Pregunta

Página 38 de 55
Página 39 de 55
Página 40 de 55
Respuesta actualizada

Página 41 de 55
Página 42 de 55
Comprobar si se han respondido todas las preguntas para guardar puntuación

Esta comprobación se realiza en el diálogo anterior, revisando si el número de preguntas contestadas es

igual al de las formuladas. Cuando esto ocurra se lanzará un segundo diálogo con un EditText para recoger el
nombre del jugador y darle la opción de guardar a través de dos botones. Si se acepta, mediante un método
de la base de datos se añade en ella el nombre del jugador y su puntuación.

Con esta última activity finalizaría la explicación de la aplicación, aunque podríamos realizar ahora alguna
de las mejoras disponibles, como mostrar una progressbar indeterminate mientras cargan las preguntas o
situar botones en la pantalla de agradecimientos que permitan acceder a la web de los recursos citados sin
necesidad de salir de la aplicación.

Publicar en Google Play

Introducción

Google Play es la tienda oficial de Android (hay otras alternativas) y el principal medio de distribución para
cualquier aplicación de este Sistema Operativo.

En este apartado trataremos los puntos básicos para poder publicarlas en esta plataforma.

Página 43 de 55
Preparando la aplicación

En primer lugar, se debe preparar la aplicación eliminando todos aquellos elementos que se utilizan
en debug. A continuación, es necesario revisar que los resources utilizados sean los definitivos y cumplan
todas las normas de tamaño de iconos, lanzamiento de la aplicación…

Se debe comprobar también en el AndroidManifest o en gradle que los

atributos versionCode y versionName sean los adecuados.

versionCode es muy importante, puesto que es necesario modificarlo conforme se producen cambios en la
aplicación para actualizarla en Google Play.

Otros dos elementos a revisar son los iconos y la etiqueta que da

nombre a la app.

En cuanto al tema de las pruebas lo mejor es haber realizado las suficientes con la versión debug tanto en
simuladores como en diferentes terminales para tener la seguridad de conseguir que la aplicación se adapte
bien a los diferentes dispositivos e idiomas soportados.

Por último, se generará una APK firmada para su subida a Google Play.
Firmar una APK puede parecer complicado, pero con las herramientas de Android Studio viene todo integrado
para que sea más sencillo. Los pasos son:

Nos dirigimos al menú Build y seleccionamos Generated Signed APK….

Página 44 de 55
En la pantalla marcamos el módulo o la aplicación que se desea
firmar y pulsamos Next.

Página 45 de 55
Si no tenemos firma se generará una nueva con Create new.

Se selecciona el destino del archivo que contendrá la clave y se le

asigna una, indicando un nombre para poder continuar.

Página 46 de 55
A continuación, se selecciona el destino de la APK y la forma de la
firma (es conveniente utilizar V1 y V2) y se pulsa Finish para
comenzar el proceso.

Al cabo de unos minutos aparecerá la APK en la ubicación

especificada.

Página 47 de 55
En este punto se dispone de una APK lista para instalar en dispositivos y hacer las últimas comprobaciones
o bien para subirla a Google Play. También se puede obtener un APK sin firma que suele utilizarse para
testeos.

Es muy importante no perder la clave generada ni olvidar la contraseña, ya que una vez firmada una
aplicación con ella y subida a Google Play solo se podrá modificar o subir una APK nueva que haya sido firmada
con esa clave.

Página 48 de 55
Cuenta de desarrollo y publicación

Android es un sistema muy abierto, pero para utilizar Google Play como plataforma de distribución es
necesario tener en primer lugar una cuenta de desarrollador. Los pasos son los siguientes:

Se accede a Google Play Console y se inicia sesión con una cuenta de

Gmail.

A continuación, se acepta el acuerdo de desarrolladores.

Por último, se paga una cuota de 25$ y se terminan de completar

nuestros datos.

Página 49 de 55
Esta cuenta es permanente y, a día de hoy, solo debe realizarse un único pago sin importar el número de
aplicaciones que desarrollemos.

Con estos pasos ya se tendría habilitada una cuenta para el desarrollo y podría accederse a la Google Play
Console, desde donde administrar la distribución de la aplicación.

A continuación, debemos completar las características de la aplicación.

Ficha
Para subir una aplicación el primer paso consiste en crear una nueva ficha y completarla con nombre, idioma
predeterminado, breve descripción y capturas de pantalla en diferentes dispositivos. A esta sección se la
conoce como Ficha de Play Store.

Página 50 de 55
Versiones de la aplicación
A continuación, se debe subir la APK a Google Play a través del apartado “Versiones de la aplicación”, donde
se debe escoger el tipo de versión que se desea dar de alta, principalmente producción, beta o alfa.

Página 51 de 55
Se producirá una validación de la APK y, si no se supera, será necesario revisar qué paso hemos ejecutado
mal.

Clasificación de contenido
Una vez subida la APK se podrá acceder a la “Clasificación de Contenido” donde se debe responder una serie
de preguntas para indicar qué clase de aplicación es. También pueden figurar algunas que hagan referencia al
público objetivo o al tipo de aplicación.

Página 52 de 55
Una vez superada la clasificación se obtiene un pequeño certificado en el que viene indicada.

Precio y distribución
Por último, en la sección "Precio y distribución" hay que indicar si la aplicación es gratuita o de pago, en qué
países se quiere distribuir y, lo más importante, si está publicada o no.

Página 53 de 55
Es importante mencionar que una aplicación gratuita no podrá pasar a ser de pago. Si queremos empezar a
cobrar por ella debemos subir una nueva y Google recibirá una comisión del 30% de su importe.

En la parte final de este menú aparece una serie de consentimientos que se deberán revisar y permitir para
poder distribuir la app.

Una vez completados todos esto requisitos, escogido la opción de APK de producción y marcada la distribución
como “publicada”, pasadas unas horas debería estar disponible para descargar e instalar desde Google Play
Store.

Página 54 de 55
Resumen
En el primer punto de este tema se describió el proceso mediante el cual una serie de ideas generales se
van convirtiendo en las diferentes funciones y pantallas que conforman una aplicación, apoyándonos en una
serie de controles nuevos relacionados en gran medida con algo muy necesario como es el trabajo con listas,
tanto el ListView como el RecyclerView.

En la segunda parte se realizó el paso final de cualquier desarrollo de software: la distribución a los
usuarios. En este caso, se ha descrito cómo generar el ejecutable de una aplicación Android y los pasos y
credenciales necesarias para subirlo a una plataforma a nivel mundial como es Google Play Store.

Página 55 de 55