Android Studio

Programación Avanzada
Mendoza Apaza, Fernando
5¿ Ciclo. Semestre:2020-I

Quispe Laveriano, César Augusto 1713210136 (02L-91G).

Gallardo Ramirez, Jesús Anderson 1713220537 (02L-93G).
Abanto Palomino, Joe Kevin 1713220422 (02L-93G).

pág. 1
Índice
Presentación………………………………………………………….. 3
Introducción a Android Studio……………………………………….. 4
¿Qué es Android Studio?...................................................................... 5
¿Qué podemos hacer con Android Studio?........................................... 5
Lenguajes para programar aplicaciones en Android…………………. 6
Componentes de una aplicación…………………………………….... 7
Descripción general de proyectos……………………………………. 9
Cómo escribir tu app…………………………………………………. 11
Cómo compilar y ejecutar una app…………………………………… 12
Configura tu compilación…………………………………………….. 13
Cómo depurar tu app…………………………………………………. 14
Cómo probar tu app…………………………………………………... 15
Perfila el rendimiento de tu app……………………………………… 17
Publica tu app………………………………………………………… 18
Herramientas de línea de comandos………………………………….. 20
Ejemplos……………………………………………………………… 22
Conclusiones…………………………………………………………. 25
Bibliografía…………………………………………………………… 26

pág. 2
Presentación
En este breve trabajo de investigación que realizamos en conjunto abarcaremos
el tema de Android Studio, ¿Qué es? ¿para qué sirve?
Como ya sabemos Android Studio es un programa para crear app(aplicaciones)
para Android.
Abarcaremos los lenguajes utilizados en este programa, su funcionamiento y los
componentes de una aplicación.
También añadiremos algunos pasos importantes para el desarrollo de la app,
algunos consejos y codigo utilizados en el programa (los más usados o más
importantes). Como también como compilar o comprobar si nuestra app está
correctamente hecha o tiene algunos fallos, para eso tenemos el emulador que es
una herramienta muy útil del programa que se resaltara más adelanto.
También mostraremos como podemos observar el rendimiento de nuestra app,
su correcto uso ya sea el nivel de batería, etc. Y como podrías publicar tu app ya
sea por app store o por otro sitio web.
Para finalizar decidimos crear una pequeña aplicación usando Android Studio,
mostraremos los pasos y el producto final.

pág. 3
Introducción a Android Studio
Android Studio es el entorno de desarrollo integrado (IDE) oficial para el desarrollo de apps
para Android, basado en IntelliJ IDEA. Además del potente editor de códigos y las
herramientas para desarrolladores de IntelliJ, Android Studio ofrece incluso más funciones
que aumentan tu productividad cuando desarrollas apps para Android, como las siguientes:
Un sistema de compilación flexible basado en Gradle
Un emulador rápido y cargado de funciones
Un entorno unificado donde puedes desarrollar para todos los dispositivos Android
Aplicación de cambios para insertar cambios de códigos y recursos a la aplicación en
ejecución sin reiniciar la aplicación
Integración con GitHub y plantillas de código para ayudarte a compilar funciones de
apps comunes y también importar código de muestra
Variedad de marcos de trabajo y herramientas de prueba
Herramientas de Lint para identificar problemas de rendimiento, usabilidad y
compatibilidad de la versión, entre otros
Compatibilidad con C++ y NDK
Compatibilidad integrada con Google Cloud Platform, que facilita la integración con
Google Cloud Messaging y App Engine.

pág. 4
¿Qué es Android Studio?
Android Studio es un entorno de desarrollo, un software, que cuenta con herramientas y
servicios para que los desarrolladores puedan crear nuevas aplicaciones para Android.
Muchos de los sistemas operativos actuales cuentan con este tipo de entornos de desarrollo,
algo que ocurre también en el sistema operativo de Google.
En este entorno de desarrollo nos encontraremos con las herramientas que son necesarias para
crear aplicaciones. Esto incluye desde el código, al diseño de la interfaz de usuario de la
aplicación. Va a poder guiar a dicho creador en todo el proceso, para poder obtener de esta
manera una aplicación, que se podrá publicar posteriormente en la Play Store, por ejemplo.
Los que quieran usar Android Studio lo podrán descargar en su ordenador, compatible con
Windows, MacOS, ChromeOS y Linux, para poder trabajar en el mismo en la creación de
dicha aplicación. Ningún desarrollador se encontrará por tanto con problemas para tener
acceso a este entorno y poder trabajar con el mismo.

¿Qué podemos hacer con Android Studio?

Android Studio está diseñado para que podamos realizar varias acciones, todas ellas
relacionadas con la creación de aplicaciones para Android. Es por eso, que muchos lo ven
como un servicio o herramienta imprescindible para los desarrolladores. Podemos hacer uso
del mismo para diversas cosas:

Crea una aplicación: Es la principal finalidad que nos ofrece este software, ya que, de
una forma sencilla, gracias a una interfaz que es fácil de usar y muy visual, los
usuarios podrán crear sus propias aplicaciones. Además, se proporcionan diseños e
interfaces, en función del tipo de app, para ayudar con su desarrollo.
Usar como emulador de Android: Android Studio cuenta con un emulador, que
podremos usar para probar funciones del sistema operativo o probar las aplicaciones
que hayamos creado en el teléfono, para ver si hay algo que modificar o si todo
funciona según lo esperado.
Analizar otras apps: Una buena función, sobre todo para aquellos que tienen interés en
aprender sobre el diseño de aplicaciones. Una función que está disponible también es
la de analizar o usar el trabajo de otros desarrolladores, ya que podemos usar
aplicaciones de código abierto, para aprender sobre cómo se han diseñado o para usar
parte de su código en un proyecto propio.
Ejecutar aplicaciones: Como ya hemos mencionado antes, Android Studio nos permite
probar esas aplicaciones que hayamos creado en el teléfono, usando para ello la
depuración USB. Una buena forma de comprobar que todo está bien y que la
aplicación se puede publicar o para detectar fallos.

pág. 5
LENGUAJES PARA PROGRAMAR APLICACIONES EN ANDROID
Aplicación nativa vs. aplicación web:
Antes de empezar, debemos asimilar la diferencia entre aplicación nativa y aplicación web, ya
que será un concepto importante para poder diferenciar los lenguajes que vamos a analizar.
Aplicación web: Usa lenguajes web, habitualmente HTML5 y CSS, para poder hacer
tareas muy sencillas, como hacer una conversión de un sitio online a la pantalla del
teléfono. Por su contra, no son capaces de aprovechar todo el hardware del dispositivo,
como la cámara.
Aplicación nativa: La más potente. Usa el lenguaje del sistema operativo de la
plataforma, logrando aprovechar todo el potencial del dispositivo, tanto a nivel de
hardware como de software. En el caso de Android, el lenguaje es Java.

Lenguajes de programación de aplicaciones para Android:

Java:
Es el lenguaje nativo que usa Android. Cualquier aplicación que use directamente el hardware
y se comunique con el sistema operativo, usará este código. Es un lenguaje muy extendido,
presente en muchos dispositivos, tanto por la red como a nivel local y aprender a programar
en él, no sólo nos permitirá hacer aplicaciones para el sistema de Google, sino también para
otros usos, como programas de escritorio, o incluso videojuegos.
JavaScript:
No confundir con Java, pese a que el nombre se parece. No tienen nada que ver. De hecho,
JavaScript es un lenguaje web, pero con plataformas de desarrollo como Titanium de,
Appcelerator, seremos capaces de compilar de manera nativa con la facilidad que ofrece
frente a Java. ¿A qué se debe esto? Los lenguajes web suelen ser más sencillos y ligeros que
los nativos. Nosotros escribiremos las instrucciones en JavaScript, y Titanium se encarga por
nosotros de “traducirlo” al lenguaje nativo, no sólo de Android, también de iOS o Windows
10 Mobile. De modo que podremos acceder, también, a los recursos físicos del dispositivo
(cámara, GPS, acelerómetro, etc.). ¿Cómo funciona? Nosotros escribimos en JavaScript el
código que necesitamos para hacer funcionar la aplicación. En el caso de Titanium, contamos
con una extensa API a nuestro favor, con métodos y funciones que hacen tareas por nosotros.
Una vez escrito, Titanium lo “lee” y lo va traduciendo para que el dispositivo lo entienda en
su idioma. Digamos que, de manera abstracta, Titanium actúa como un traductor para que
terminal y desarrollador se entiendan.
HTML5 + CSS:
Lenguajes 100% web. Aquí no hay discusión posible. Estos dos lenguajes de etiquetación
fueron creados para internet, pero el paso del tiempo los ha beneficiado, sobre todo con la
llegada de la versión 5 de HTML. Esta versión ofrece muchas posibilidades respecto la
versión 4, entre ellas reproducir vídeo de un modo más nativo en el navegador, sin la ayuda de

pág. 6
flash, algo que reduce considerablemente el consumo de recursos. Pero la cosa no queda aquí.
Al igual que ocurre con JavaScript, plataformas como Titanium permiten el desarrollo de este
tipo de aplicaciones con estos lenguajes. Por lo que, si ya con JavaScript el trabajo reducía en
complejidad, con esto se vuelve un paseo a la hora de asimilarlo, contando también que todo
lo que aprendáis enfocado a aplicaciones web os servirá para paginación web, porqué el
concepto es el mismo: una estructura web que, en vez de apuntar a pantallas grandes de
escritorio, apunta a pantallas más pequeñas de dispositivos móviles.

COMPONENTES DE UNA APLICACIÓN

Existe una serie de elementos clave que resultan imprescindibles para desarrollar aplicaciones
en Android. En este apartado vamos a realizar una descripción inicial de algunos de los más
importantes.

Vista (View):
Las vistas son los elementos que componen la interfaz de usuario de una aplicación: por
ejemplo, un botón o una entrada de texto. Todas las vistas van a ser objetos descendientes de
la clase View y por tanto, pueden ser definidas utilizando código Java. Sin embargo, lo
habitual será definir las vistas utilizando un fichero XML y dejar que el sistema cree los
objetos por nosotros a partir de este fichero. Esta forma de trabajar es muy similar a la
definición de una página web utilizando código HTML.
Layout(diseño):
Un layout es un conjunto de vistas agrupadas de una determinada forma. Vamos a disponer de
diferentes tipos de layouts para organizar las vistas de forma lineal, en cuadrícula o indicando
la posición absoluta de cada vista. Los layouts también son objetos descendientes de la clase
View. Igual que las vistas, los layouts pueden ser definidos en código, aunque la forma
habitual de definirlos es utilizando código XML.
Actividad (Activity):
Una aplicación en Android va a estar formada por un conjunto de elementos básicos de
visualización, coloquialmente conocidos como pantallas de la aplicación. En Android cada
uno de estos elementos, o pantallas, se conoce como actividad. Su función principal es la
creación de la interfaz de usuario. Una aplicación suele necesitar varias actividades para crear
la interfaz de usuario. Las diferentes actividades creadas serán independientes entre sí, aunque
todas trabajarán para un objetivo común. Una actividad se define en una clase descendiente de
Activity y utiliza un layout para que define su apariencia.
Fragmentos (Fragment):
La llegada de las tabletas trajo el problema de que las aplicaciones de Android ahora deben
soportar pantallas más grandes. Si diseñamos una aplicación pensada para un dispositivo
móvil y luego la ejecutamos en una tableta, el resultado no suele resultar satisfactorio.

pág. 7
Para ayudar al diseñador a resolver este problema, en la versión 3.0 de Android aparecen los
fragments. Un fragment está formado por la unión de varias vistas para crear un bloque
funcional de la interfaz de usuario. Una vez creados los fragments, podemos combinar uno o
varios fragments dentro de una actividad, según el tamaño de pantalla disponible.
El uso de fragments puede ser algo complejo, por lo que recomendamos dominar primero
conceptos como actividad, vista y layout antes de abordar su aprendizaje. No obstante, es un
concepto importante en Android y todo programador en esta plataforma ha de saber
utilizarlos.
Servicio (Service):
Un servicio es un proceso que se ejecuta “detrás”, sin la necesidad de una interacción con el
usuario. Es algo parecido a un demonio en Unix o a un servicio en Windows. Se utilizan
cuando queramos tener en ejecución un código de manera continua, aunque el usuario cambie
de actividad. En Android disponemos de dos tipos de servicios: servicios locales, que son
ejecutados en el mismo proceso, y servicios remotos, que son ejecutados en procesos
separados.
Intención (Intent):
Una intención representa la voluntad de realizar alguna acción; como realizar una llamada de
teléfono, visualizar una página web. Se utiliza cada vez que queramos:
Lanzar una actividad.
Lanzar un servicio.
Enviar un anuncio de tipo broadcast.
Comunicarnos con un servicio.
Los componentes lanzados pueden ser internos o externos a nuestra aplicación. También
utilizaremos las intenciones para el intercambio de información entre estos componentes.
Receptor de anuncios (Broadcast Receiver):
Un receptor de anuncios recibe anuncios broadcast y reacciona ante ellos. Los anuncios
broadcast pueden ser originados por el sistema (por ejemplo: Batería baja, Llamada entrante)
o por las aplicaciones. Las aplicaciones también pueden crear y lanzar nuevos tipos de
anuncios broadcast. Los receptores de anuncios no disponen de interfaz de usuario, aunque
pueden iniciar una actividad si lo estiman oportuno.
Proveedores de Contenido (Content Provider):
En muchas ocasiones las aplicaciones instaladas en un terminal Android necesitan compartir
información. Android define un mecanismo estándar para que las aplicaciones puedan
compartir datos sin necesidad de comprometer la seguridad del sistema de ficheros. Con este
mecanismo podremos acceder a datos de otras aplicaciones, como la lista de contactos, o
proporcionar datos a otras aplicaciones.

pág. 8
DESCRIPCIÓN GENERAL DE PROYECTOS
Un proyecto de Android Studio contiene todo lo que define tu lugar de trabajo para una app:
desde código fuente y recursos hasta código de prueba y configuraciones de compilación.
Cuando comienzas un proyecto nuevo, Android Studio crea la estructura necesaria para todos
los archivos y los hace visibles en la ventana Proyecto del lado izquierdo del IDE.

Módulos:
Un módulo es un conjunto de archivos fuente y opciones de configuración de compilación
que te permiten dividir tu proyecto en unidades discretas de funcionalidad. Tu proyecto puede
tener uno o más módulos, y un módulo puede usar otro como dependencia. Cada módulo se
puede compilar, probar y depurar de forma independiente.
Los módulos adicionales a menudo son útiles cuando creas bibliotecas de código dentro de tu
propio proyecto o si deseas crear diferentes conjuntos de código y recursos para distintos tipos
de dispositivos, como teléfonos y wearables, y al mismo tiempo mantener todos los archivos
almacenados dentro del mismo proyecto y compartir código.

Archivos de proyecto:
De forma predeterminada, Android Studio muestra los archivos de tu proyecto en la vista
Android. Esta vista no refleja la jerarquía real de los archivos en el disco, pero se organiza en
módulos y tipos de archivos para simplificar la navegación entre los principales archivos
fuente de tu proyecto, con lo cual se ocultan determinados archivos o directorios que no se
usan con frecuencia. En comparación con la estructura en el disco, estos son algunos de los
cambios estructurales:
Se muestran todos los archivos de configuración relacionados con la compilación del
proyecto en un grupo de nivel superior Gradle Script.
Se muestran todos los archivos de manifiesto para cada módulo en un grupo de nivel
de módulo (cuando tienes diferentes archivos de manifiesto para diferentes clases de
productos y tipos de compilación).
Se muestran todos los archivos de recursos alternativos en un único grupo, en lugar de
carpetas separadas por calificador de recursos. Por ejemplo, todas las versiones de
densidad de tu ícono de selector son visibles en paralelo.
Dentro de cada módulo de app para Android, los archivos se muestran en los siguientes
grupos:
 manifests
Contiene el archivo AndroidManifest.xml.
 java

pág. 9
Contiene los archivos de código fuente Java separados por nombres de paquetes, incluido el
código de prueba JUnit.
 res
Contiene todos los recursos sin código, como diseños XML, strings de IU y también imágenes
de mapa de bits, divididos en subdirectorios pertinentes.

Vista de proyectos de Android:

Para ver la estructura de archivos real del proyecto, incluidos todos los archivos ocultos de la
vista de Android, selecciona Project en el menú desplegable de la parte superior de la ventana
Project.
Cuando seleccionas la vista Proyecto, puedes ver más archivos y directorios. Los más
importantes son los siguientes:
module-name/
 build/
Contiene resultados de compilación.
 libs/
Contiene bibliotecas privadas.
 src/
Contiene todos los archivos de código y recursos para el módulo en los siguientes
subdirectorios:
 androidTest/
Contiene código para las pruebas de instrumentación que se ejecutan en un dispositivo
Android. Para obtener más información, consulta la sección de documentación de prueba para
Android.
 main/
Contiene los archivos de conjunto de fuentes "principales": el código y los recursos de
Android compartidos por todas las variantes de compilación (los archivos para otras variantes
de compilación residen en directorios del mismo nivel, como src/debug/ para el tipo de
compilación de depuración).
 AndroidManifest.xml
Describe la naturaleza de la aplicación y cada uno de sus componentes. Para obtener más
información, consulta la documentación de AndroidManifest.xml.
 java/

pág. 10
Contiene fuentes de código Java.
 jni/
Contiene código nativo en el cual se usa la interfaz nativa de Java (JNI). Para obtener más
información, consulta la sección de documentación de NDK de Android.
 gen/
Contiene los archivos Java que genera Android Studio, como el archivo R.java y las interfaces
creadas desde los archivos AIDL.
 res/
Contiene recursos de aplicación, como archivos de elementos de diseño, archivos de diseño y
strings de IU.
 assets/
Contiene el archivo que se debe compilar en un archivo.apk tal como está. Puedes navegar
este directorio como un sistema de archivos típico mediante URI y leer archivos como
transmisiones de bytes con AssetManager. Por ejemplo, es una buena ubicación para texturas
y datos de juegos.
 test/
Contiene código para pruebas locales que se ejecutan en tu JVM de host.
 build.gradle (módulo)
Este archivo define las configuraciones de compilación específicas para el módulo.
 build.gradle (proyecto)
Este archivo define tu configuración de compilación que se aplica a todos los módulos. Es
esencial para el proyecto. Por lo tanto, debes someterlo a control de revisión con todo el
código fuente restante.

CÓMO ESCRIBIR TU APP

Android Studio incluye herramientas para cada etapa de desarrollo, pero lo más importante es
la escritura de tu app: escribir el código, compilar diseños, crear imágenes y ser productivo a
lo largo del proceso.
De eso se trata esta sección: herramientas que te ayudarán a escribir rápidamente el código de
tu app.
Cómo completar el código:

pág. 11
La función para completar el código acelera el desarrollo de apps, ya que reduce los errores de
escritura y la necesidad de buscar nombres de clases, métodos y variables. El editor de código
permite hacerlo de manera básica, inteligente y con enunciados.
Cómo crear plantillas personalizadas para completar código:
Las plantillas dinámicas te permiten ingresar fragmentos de código a fin de insertar y
completar rápidamente fragmentos de códigos pequeños. Para insertar una plantilla dinámica,
escribe su abreviatura y presiona la tecla Tab. Android Studio inserta en tu código el
fragmento asociado con la plantilla.
Cómo realizar correcciones rápidas desde Lint:
Android Studio proporciona una herramienta de exploración de códigos llamada Lint que te
permite identificar y corregir problemas relacionados con la calidad estructural de tu código
sin ejecutar la app ni escribir código de prueba.
Cada vez que compilas tu app, Android Studio ejecuta Lint para verificar tus archivos de
origen en busca de posibles errores y mejoras de optimización relacionadas con la seguridad,
el rendimiento, la precisión, la usabilidad, la accesibilidad y la internacionalización.

CÓMO COMPILAR Y EJECUTAR UNA APP

Android Studio configura proyectos nuevos para implementar en Android Emulator o en un
dispositivo conectado con unos pocos clics. Una vez que se instala la app, puedes usar Apply
Changes para implementar ciertos cambios de código y recursos sin compilar un APK nuevo.
Para compilar y ejecutar la app, sigue estos pasos:
 En la barra de herramientas, selecciona la app en el menú desplegable de
configuraciones de ejecución.
 En el menú desplegable del dispositivo de destino, selecciona el dispositivo en el que
deseas ejecutar la app.
Menú desplegable del dispositivo de destino.
Si no tienes ningún dispositivo configurado, debes conectar un dispositivo mediante USB o
crear un AVD para usar Android Emulator.
Haz clic en Run.

Cómo ejecutar apps en Android Emulator:

Android Emulator simula dispositivos Android en una computadora para que puedas probar tu
app en diferentes dispositivos y niveles de API de Android sin necesidad de contar con los
dispositivos físicos.

pág. 12
El emulador proporciona casi todas las funciones de un dispositivo Android real. Puedes
simular llamadas y mensajes de texto entrantes, especificar la ubicación del dispositivo,
utilizar diferentes velocidades de red, probar sensores de rotación y otros sensores de
hardware, acceder a Google Play Store y mucho más.
En algunos casos, probar tu app en el emulador es más rápido y fácil que hacerlo en un
dispositivo físico. Por ejemplo, puedes transferir datos con mayor velocidad al emulador que
a un dispositivo conectado mediante USB.
El emulador incluye configuraciones predefinidas para varios teléfonos y tablets Android,
Wear OS y dispositivos Android TV.
Puedes usar el emulador de forma manual, a través de la interfaz gráfica de usuario y de
forma programática, mediante la línea de comandos y la consola del emulador.

Dispositivos virtuales de Android:

Cada instancia de Android Emulator usa un dispositivo virtual de Android (AVD) para
especificar la versión de Android y las características del hardware del dispositivo simulado.
Si quieres probar tu app de manera eficaz, deberás crear un AVD que modele cada dispositivo
en el que se ejecutará la app según su diseño. Para crear y administrar AVD, usa el
Administrador de AVD.
Cada AVD funciona como un dispositivo independiente, con su propio almacenamiento
privado para datos de usuario, tarjetas SD, etc. De forma predeterminada, el emulador
almacena los datos del usuario, el contenido de la tarjeta SD y la memoria caché en un
directorio específico para ese AVD. Cuando inicies el emulador, este cargará los datos del
usuario y el contenido de la tarjeta SD desde el directorio del AVD

CONFIGURA TU COMPILACIÓN
El sistema de compilación de Android compila recursos y código fuente de la app y los
empaqueta en APK que puedes probar, implementar, firmar y distribuir. Android Studio usa
Gradle, un paquete de herramientas de compilación avanzadas, para automatizar y administrar
el proceso de compilación, y al mismo tiempo definir configuraciones de compilación
personalizadas y flexibles. Cada configuración de compilación puede definir su propio
conjunto de código y recursos, y reutilizar las partes comunes a todas las versiones de tu app.
El complemento de Android para Gradle funciona con el paquete de herramientas de
compilación a fin de proporcionar procesos y ajustes configurables específicos para la
compilación y prueba de apps para Android.
Gradle y el complemento de Android se ejecutan independientemente de Android Studio. Por
lo tanto, puedes compilar tus apps para Android desde Android Studio, la línea de comandos
en tu máquina o en máquinas en las que no esté instalado Android Studio (como servidores de
integración continua). Si no usas Android Studio, puedes aprender a compilar y ejecutar tu

pág. 13
app desde la línea de comandos. El resultado de la compilación es el mismo si compilas un
proyecto desde la línea de comandos en una máquina remota o con Android Studio.

La flexibilidad del sistema de compilación de Android te permite realizar configuraciones de

compilación personalizadas sin modificar los archivos de fuente principales de tu app
Proceso de compilación:
En el proceso de compilación, se incluyen muchas herramientas y procesos que convierten tu
proyecto en un paquete de aplicaciones para Android (APK). El proceso de compilación es
muy flexible, por lo que resulta útil comprender algo de lo que ocurre en niveles más
profundos.
El proceso de compilación para un módulo de app para Android:
Los compiladores convierten tu código fuente en archivos DEX (ejecutable de Dalvik), que
incluyen el código de bytes que se ejecuta en dispositivos Android, y todo lo demás en
recursos compilados.
El empaquetador de APK combina los archivos DEX y los recursos compilados en un solo
APK. No obstante, antes de que tu app pueda instalarse y también implementarse en un
dispositivo Android, se debe firmar el APK.
El empaquetador de APK firma tu APK usando el almacén de claves de depuración o
lanzamiento:
Si compilas una versión de depuración de tu app (es decir, una app que solo desees usar para
pruebas y generación de perfiles), el empaquetador firmará tu app con el almacén de claves de
depuración. Android Studio configura automáticamente nuevos proyectos con un almacén de
claves de depuración.
Si compilas una versión de actualización de tu app que quieres lanzar de manera externa, el
empaquetador firmará tu app con el almacén de claves de lanzamiento. Para crear un almacén
de claves de lanzamiento, lee la sección sobre cómo firmar apps en Android Studio.
Antes de generar tu APK final, el empaquetador usa la herramienta zipalign para optimizar tu
app de modo que use menos memoria cuando se ejecute en un dispositivo.
Al final del proceso de compilación, tendrás un APK de depuración o un APK de lanzamiento
de tu app que podrás usar a fin de implementar, probar o lanzar tu app para usuarios externos.

CÓMO DEPURAR TU APP

Android Studio proporciona un depurador que te permite realizar las siguientes acciones y
más:
Seleccionar un dispositivo en el cual depurarás tu app
Establecer interrupciones en tu código Java, Kotlin y C/C++

pág. 14
Examinar variables y evaluar expresiones en el tiempo de ejecución
Cómo habilitar la depuración
Antes de comenzar a depurar, debes prepararte de la siguiente manera:
Habilita la depuración en tu dispositivo:
Si estás usando el emulador, esta opción estará activada de forma predeterminada. Sin
embargo, en el caso de un dispositivo conectado, deberás habilitar la depuración en las
opciones para desarrolladores del dispositivo.
Ejecuta una variante de compilación depurable:
Debes usar una variante de compilación que incluya debuggable true en la configuración de
compilación. Por lo general, simplemente puedes seleccionar la variante de "depuración"
predeterminada que se incluye en cada proyecto de Android Studio (aunque no esté visible en
el archivo build.gradle). Sin embargo, si defines nuevos tipos de compilación que deberían ser
depurables, debes agregar "debuggable true" al tipo de compilación:
Esta propiedad también se aplica a los módulos con código C o C++ (ya no se usa la
propiedad jniDebuggable).
Si tu app depende de un módulo de biblioteca que también quieres depurar, también se debe
empaquetar esa biblioteca con debuggable true de manera que conserve sus símbolos de
depuración. Para garantizar que las variantes depurables del proyecto de tu app reciban la
variante depurable de un módulo de biblioteca, asegúrate de publicar versiones no
predeterminadas de tu biblioteca.

CÓMO PROBAR TU APP

Android Studio está diseñado para simplificar la ejecución de pruebas. Con solo algunos clics,
puedes configurar una prueba JUnit que se ejecute en el JVM local o una prueba
instrumentada que se ejecute en un dispositivo. Por supuesto, también puedes extender tus
capacidades de pruebas integrando marcos de trabajo de prueba como Mockito para probar las
llamadas de API de Android en tus pruebas de unidades locales y Espresso o UI Automator
para ejercitar la interacción con usuarios en pruebas instrumentadas. Puedes generar
automáticamente pruebas Espresso con Espresso Test Recorder.
Tipos de pruebas y ubicación:
La ubicación del código de tu prueba dependerá del tipo de prueba que escribas. Android
Studio proporciona directorios de código fuente (conjuntos fuente) para los siguientes dos
tipos de pruebas:

 Pruebas de unidad local

Ubicación: module-name/src/test/java/.

pág. 15
Estas son pruebas que se ejecutan en la máquina virtual Java (JVM) local de tu máquina. Usa
estas pruebas para minimizar el tiempo de ejecución cuando tus pruebas no tengan
dependencias de marco de Android o cuando puedas simular las dependencias del marco de
Android.
En el tiempo de ejecución, las pruebas se ejecutan en relación con la versión modificada de
(android.jar), en la que se quitan todos los modificadores (final). De esta manera, puedes usar
bibliotecas de simulación populares, como Mockito.

 Pruebas instrumentadas
Ubicación: module-name/src/androidTest/java/.
Estas son pruebas que se ejecutan en un dispositivo o emulador de hardware. Estas pruebas
tienen acceso a las API de Instrumentation, te brindan acceso a información como el Context
de la app que estás probando y te permiten controlar la app desde el código de prueba. Usa
estas pruebas cuando escribas pruebas de IU integradoras y funcionales para automatizar la
interacción de usuarios, o cuando tus pruebas tengan dependencias de Android que los objetos
ficticios no puedan contemplar.
Debido a que las pruebas instrumentadas se compilan en un APK (por separado del APK de tu
app), deben tener su propio archivo AndroidManifest.xml. Sin embargo, Gradle genera
automáticamente este archivo durante la compilación para que no se vea en el conjunto de
fuentes de tu proyecto. Puedes agregar tu propio archivo de manifiesto si es necesario, por
ejemplo, a fin de especificar un valor diferente para "minSdkVersion" o registrar receptores
de ejecución solo para tus pruebas. Cuando se compila tu app, Gradle combina varios
archivos de manifiesto en uno solo.

Monkeyrunner:
La herramienta monkeyrunner proporciona una API para escribir programas que controlan un
dispositivo o emulador de Android fuera del código de Android. Con monkeyrunner, puedes
escribir un programa de Python que instale una aplicación de Android o un paquete de prueba,
lo ejecute, envíe combinaciones de teclas, tome capturas de pantalla de la interfaz de usuario y
almacene esas imágenes en la estación de trabajo. La herramienta monkeyrunner está
diseñada principalmente para probar aplicaciones y dispositivos a nivel funcional o de marco
de trabajo, y para ejecutar conjuntos de pruebas de unidades, aunque puedes usarla con otros
fines.
La herramienta monkeyrunner no está relacionada con la herramienta de pruebas Monkey
para IU y aplicaciones, también conocida como herramienta monkey. La herramienta monkey
se ejecuta directamente en el shell adb del dispositivo o emulador, y genera flujos
pseudoaleatorios de los eventos del usuario y del sistema. En comparación, la herramienta
monkeyrunner controla los dispositivos y emuladores desde una estación de trabajo mediante
el envío de comandos y eventos específicos desde una API.

pág. 16
La herramienta monkeyrunner proporciona estas funciones únicas para pruebas de Android:
Control de varios dispositivos: La API de monkeyrunner puede aplicar uno o más
conjuntos de pruebas en varios dispositivos o emuladores. Puedes conectar físicamente
todos los dispositivos o iniciar todos los emuladores a la vez (o ambos), conectar cada
uno de forma programática y luego ejecutar una o más pruebas. También puedes
iniciar la configuración del emulador de forma programática, ejecutar una o más
pruebas y luego apagar el emulador.
Pruebas funcionales: monkeyrunner puede ejecutar una prueba automatizada de inicio
a fin de una aplicación de Android. Debes proporcionar los valores de entrada con
combinaciones de teclas o eventos de entrada táctil, y visualizar los resultados como
capturas de pantalla.
Pruebas de regresión: monkeyrunner puede probar la estabilidad de la aplicación
ejecutándola y comparando las capturas de pantalla resultantes con un conjunto de
capturas que se sabe que son correctas.
Automatización extensible: Dado que monkeyrunner es un kit de herramientas de API,
puedes desarrollar un sistema completo de módulos y programas basados en Python
para controlar dispositivos Android. Además de usar la API de monkeyrunner, puedes
usar los módulos estándar os y subprocess de Python para llamar a las herramientas de
Android, como Android Debug Bridge.

La herramienta monkeyrunner usa Jython, una implementación de Python que usa el lenguaje
de programación Java. Jython permite que la API de monkeyrunner interactúe fácilmente con
el marco de trabajo de Android. Con Jython, puedes usar la sintaxis de Python para acceder a
constantes, clases y métodos de la API.

PERFILA EL RENDIMIENTO DE TU APP

Se considera que una app tiene un rendimiento bajo si responde lentamente, muestra
animaciones entrecortadas, se bloquea, falla o consume mucha batería. Para evitar estos
problemas de rendimiento, usa las herramientas comparativas y de generación de perfiles que
se indican en esta página a fin de identificar cuándo tu app hace un uso ineficiente de los
recursos, como la CPU, la memoria, los gráficos, la red y la batería del dispositivo.
Cómo generar comparativas del código de apps:
La biblioteca de Jetpack Benchmark te permite obtener rápidamente comparativas de tu
código basado en Kotlin o en Java dentro de Android Studio La biblioteca se ocupa de la
preparación, mide el rendimiento del código y genera resultados de comparativas en la
consola de Android Studio.

pág. 17
Algunos casos prácticos incluyen desplazar un elemento RecyclerView, inflar una jerarquía
de View no trivial y realizar consultas de bases de datos.
Cómo inspeccionar la actividad de la CPU con CPU Profiler:
Reducir el uso de CPU de tu app tiene muchas ventajas; por ejemplo, proporciona una
experiencia de usuario más rápida y fluida, y prolonga la duración de la batería del
dispositivo.
Puedes usar CPU Profiler para inspeccionar el uso de la CPU de tu app y la actividad de
subprocesos en tiempo real mientras interactúas con la aplicación, o bien puedes inspeccionar
los detalles en los seguimientos de funciones, del sistema y de métodos registrados.
Se determinarán los tipos específicos de información que registre y muestre CPU Profiler
según la configuración que elijas:
 System Trace: Captura detalles específicos que te permiten inspeccionar cómo
interactúa tu app con los recursos del sistema.
 Method and function traces: Para cada subproceso del proceso de tu app, puedes
averiguar qué métodos (Java) o funciones (C/C++) se ejecutan durante un período de
tiempo, así como los recursos de CPU que consume cada método o función mientras
se ejecuta. También puedes usar seguimientos de métodos y funciones para identificar
emisores y destinatarios. Un emisor es un método o función que invoca a otro método
o función, y un destinatario es uno que es invocado. Puedes utilizar esta información
para determinar qué métodos o funciones son responsables de invocar con demasiada
frecuencia tareas particulares que tienen muchos recursos y optimizar el código de tu
app para evitar trabajos innecesarios.
Cuando registras seguimientos de métodos, puedes elegir registros muestreados o
instrumentados. Para registrar seguimientos de funciones, solo puedes utilizar el registro
muestreado.

PUBLICA TU APP
La publicación es el proceso general por el cual tus aplicaciones para Android se ponen a
disposición de los usuarios. Cuando publicas una app, realizas dos tareas principales:

 Preparas la app para su lanzamiento.

Durante el paso de preparación, compilas una versión de lanzamiento de tu app que los
usuarios pueden descargar e instalar en sus dispositivos Android.

 Realizas el lanzamiento de la app para los usuarios.

pág. 18
Durante el paso de lanzamiento, publicitas, vendes y distribuyes la versión de actualización de
tu app para los usuarios.

Cómo preparar tu app para el lanzamiento:

La preparación de tu app para el lanzamiento es un proceso de varios pasos que implica las
siguientes tareas:
 Cómo configurar tu aplicación para el lanzamiento
Como mínimo, debes quitar las llamadas de Log y el atributo android:debuggable de tu
archivo de manifiesto. También debes proporcionar valores para los atributos
android:versionCode y android:versionName, que se encuentran en el elemento <manifest>.
Asimismo, es posible que debas configurar varios ajustes para cumplir con los requisitos de
Google Play o adaptar cualquier método que uses para lanzar tu app.
Si usas los archivos de compilación de Gradle, puedes emplear el tipo de compilación de
lanzamiento a fin de configurar tus ajustes de compilación para la versión publicada de tu app.
 Cómo compilar y firmar una versión de actualización de tu aplicación
Puedes usar los archivos de compilación de Gradle con el tipo de compilación de lanzamiento
a fin de compilar y firmar una versión de actualización de tu aplicación.
 Probar la versión de lanzamiento de tu app
Antes de distribuir tu app, debes probar por completo la versión de lanzamiento en al menos
un teléfono celular y una tablet de destino.
 Actualizar los recursos de la app para el lanzamiento
Asegúrate de que todos los recursos de la app, como los archivos y gráficos multimedia, estén
actualizados y se incluyan con tu app o por etapas en los servidores de producción
correspondientes.
 Preparar servidores y servicios remotos de los cuales dependa tu app
Si tu app depende de servidores o servicios externos, debes controlar que sean seguros y estén
listos para la producción.
Es posible que debas realizar varias tareas como parte del proceso de preparación. Por
ejemplo, deberás obtener una clave privada para iniciar sesión en tu app. También deberás
crear un ícono, así como preparar un contrato de licencia para el usuario final (CLUF) a fin de
proteger tu persona, organización y propiedad intelectual.
Cuando termines de preparar tu aplicación para el lanzamiento, contarás con un archivo (.apk)
firmado que puedes distribuir entre los usuarios.

Cómo lanzar tu app a los usuarios:

pág. 19
Puedes lanzar tus apps de Android de diferentes maneras. Por lo general, las apps se lanzan a
través de un mercado como Google Play, pero también puedes hacerlo en tu propio sitio web
o enviarlas de forma directa a los usuarios.

Cómo realizar el lanzamiento a través de un mercado de apps:

Si deseas distribuir tus apps al público más amplio posible, recurrir a un mercado de apps
como Google Play es la opción ideal.
Google Play es el principal mercado de apps de Android y la mejor forma de distribuir tus
apps a un público mundial amplio. Sin embargo, puedes distribuir tus apps en cualquier
mercado que desees o incluso usar varios.

HERRAMIENTAS DE LÍNEA DE COMANDOS

El SDK de Android se compone de varios paquetes necesarios para el desarrollo de apps.
Herramientas del SDK de Android:
Ubicadas en: android_sdk/cmdline-tools/version/bin/

 apkanalyzer
Proporciona estadísticas sobre la composición de tu APK una vez completado el proceso de
compilación.
 avdmanager
Te permite crear y administrar dispositivos virtuales de Android (AVD) desde la línea de
comandos.
 lint
Es una herramienta de escaneo de código que te ayuda a identificar y corregir problemas
relacionados con la calidad estructural de tu código.
 sdkmanager
Te permite ver, instalar, actualizar y desinstalar paquetes para el SDK de Android.

Herramientas de compilación del SDK de Android:

Ubicadas en: android_sdk/build-tools/version/
Este paquete es necesario para crear apps de Android:

pág. 20
  aapt2
Analiza, indexa y compila recursos de Android en un formato binario que está optimizado
para la plataforma Android, y empaqueta los recursos compilados en una sola salida.
 apksigner
Firma los APK y comprueba si las firmas del APK se verificarán con éxito en todas las
versiones de plataforma que admite un APK determinado.
 zipalign
Optimiza los archivos APK, ya que garantiza que todos los datos sin comprimir comiencen
con una alineación determinada en relación con el inicio del archivo.

Herramientas de la plataforma del SDK de Android:

Ubicadas en: android_sdk/platform-tools/
Estas herramientas se actualizan con cada nueva versión de la plataforma de Android para
admitir nuevas funciones (y, en ocasiones, para corregir errores o mejorar las herramientas).
Cada actualización es retrocompatible con versiones anteriores de la plataforma.

 adb
Android Debug Bridge (adb) es una herramienta versátil que te permite administrar el estado
de una instancia de emulador o dispositivo con Android. También puedes usarla para instalar
un APK en un dispositivo.
 etc1tool
Una utilidad de línea de comandos que te permite codificar imágenes PNG al estándar de
compresión ETC1 y decodificar imágenes comprimidas ETC1 de nuevo a PNG.
 fastboot
Actualiza un dispositivo con imágenes de plataforma y del sistema. Para obtener instrucciones
de escritura en la memoria flash, consulta Imágenes de fábrica para dispositivos Nexus y
Pixel.
 logcat
Esta es una herramienta que se invoca mediante adb para ver los registros de la app y del
sistema.

Android Emulator:
Ubicado en android_sdk/emulator/

pág. 21
Este paquete, que es necesario para usar el Android Emulator, incluye lo siguiente:

 emulator
Es una herramienta de emulación de dispositivos basada en QEMU que puedes usar para
depurar y probar tus aplicaciones en un entorno de tiempo de ejecución de Android real.
 mksdcard
Te ayuda a crear una imagen de disco que puedes usar con el emulador para simular la
presencia de una tarjeta de memoria externa (como una tarjeta SD).
Jetifier:
 Jetifier lee una biblioteca que usa clases de bibliotecas de compatibilidad y genera una
biblioteca equivalente que usa las clases más recientes de AndroidX.

EJEMPLOS
Tratamos de hacer una app usando el programa Android Studio, nuestra app trata o seria para
dueños de mascotas podrán saber dónde se encuentran las veterinarias más cercanas, así como
tiendas para mascotas.

Aquí colocaremos las capturas de pantalla de nuestro avance.

pág. 22
pág. 23
pág. 24
Conclusiones

En esta investigación planteamos muchos puntos en el marco de explicar sobre

cómo podríamos utilizar el programa para mejorar el rendimiento al momento
de crear y gestionar nuestra app.
Destacamos el emulador de Android Studio ya que con esta herramienta
podemos crear un celular virtual con característica distintas de cada dispositivo
como el tamaño de pantalla y la resolución, esto nos sirve para poder probar la
funcionalidad de nuestra app en diferentes dispositivos sin tener la necesidad de
poseer varios equipos móviles.
También observamos la facilidad o la ayuda que nos brinda Android Studio al
momento de programar, y tanto que podemos utilizar C++, Java y Kotlin.
Podemos usar el lenguaje que más nos acomode porque el programa, aunque se
emplea más Java, podemos pasar de codigo Kotlin a java y C++ a java Y
viceversa.
Android Studio al momento de abrir nos generara un tip de codigo que sería muy beneficioso
para personas que recién se incorporan a la programación, este tip lo puedes quitar sino lo
deseas o mantenerlo cada vez que abres el programa.
Es recomendable tener previo conocimiento de programación en java que sería la más usada
ya que si no tienes conocimientos previos no podrás realizar tus códigos. Java es el lenguaje
más usado y conocido, es recomendable saber usarlo para empezar a hacer nuestras apps
mediante Android Studio.

pág. 25
BIBLIOGRAFÍA

https://www.redeszone.net/android/android-studio-primeros-pasos/

https://developer.android.com/studio/projects

https://www.deustoformacion.com/blog/desarrollo-apps/lenguajes-para-programar-aplicaciones-
android

http://www.androidcurso.com/index.php/tutoriales-android-fundamentos/31-unidad-1-vision-
general-y-entorno-de-desarrollo/149-componentes-de-una-aplicacion

https://www.openinnova.es/cual-es-el-mejor-lenguaje-de-programacion-para-android-apps/

pág. 26