Manual PDF

Contenido
Capítulo 1 - Instalación de Android Studio ....................................... 4

1.1 Instalación de Android Studio en Windows................................................ 5
1.1.1 Pre Requisitos....................................................................................................... 5
1.1.2 Inicio de la Instalación de Android Studio .......................................... 7
1.2 Configuración del Android Studio ................................................................... 17
1.3 Instalación de Android Studio En OS X ....................................................... 20
1.4 Otras Opciones de Descarga .............................................................................. 23
1.5 Algunas Recomendaciones al Utilizar El Emulador .............................. 23
1.5.1 Activar en la Bios Tecnologia de Virtualización ............................. 23
1.5.2 Instalación IntelHaxm.exe ......................................................................... 24
Capítulo 2 - Creación de Mi Primera App ......................................... 25
2.1 Creando la Primera Aplicación.......................................................................... 26
2.1.1 Conociendo el Entorno de Trabajo ......................................................... 33
2.1.2 Conociendo la Estructura del Proyecto................................................ 34
2.1.3 Archivo colors.xml ........................................................................................... 38
2.1.4 Archivo strings.xml ......................................................................................... 38
2.1.5 Archivo styles.xml ............................................................................................ 39
2.1.6 Archivo de Manifiesto o Configuración de Nuestra App ............ 39
2.1.7 Archivo Gradle .................................................................................................... 43
2.1.8 En Otros Archivos Importantes: .............................................................. 44
2.1.9 Conociendo la Interfaz .................................................................................. 45
2.1.10 Ejecutando la Aplicación .......................................................................... 46
2.1.11 Captura de Pantalla ..................................................................................... 48
2.2 Creando Apps – Lector Codigo Barras.......................................................... 49
2.2.1 Obtenemos lo siguiente ................................................................................ 52
2.2.2 Biblioteca de escaneo .................................................................................... 53
2.2.3 Diseñamos la Interfaz ................................................................................... 54
2.2.4 Codificación de la Actividad ....................................................................... 55
2.2.5 Ejecutando la Aplicación .............................................................................. 56
Capítulo 3 – Manejo de Controles .................................................... 59
3.1 App Suma ...................................................................................................................... 60
3.1.1 Ejecutando la Aplicación .............................................................................. 69
3.1.2 Algo de Teoria - Actividad ........................................................................... 71
3.1.3 Codificando la Aplicación Suma ............................................................... 71
1
3.1.4 Algo de Teoria - Bundle................................................................................. 74
3.1.5 Continuando con la Codificando la Aplicación Suma ................... 75
3.1.6 Implementar el escucha de eventos ..................................................... 77
3.1.7 Ahora volvemos a ejecutar la Apps Suma: ........................................ 84
3.1.8 Utilizando Lambda: .......................................................................................... 85
3.1.9 Cambios necesarios en el Gradle- Lambda: ...................................... 86
3.1.10 Volviendo a Ejecutar la Aplicación Suma ....................................... 87
Capítulo 4 – Almacenamiento .......................................................... 88
4.1 Introducción a Manejo de Ficheros ............................................................... 89
4.2 Almacenamiento ....................................................................................................... 89
4.3 Manejo de Ficheros Memoria Interna .......................................................... 89
4.3.1 Memoria Interna-WRITE .............................................................................. 89
4.3.2 Creación de Proyecto Fichero1 ................................................................. 89
4.3.3 Ejecución del proyecto Fichero1.............................................................. 95
4.3.4 Observación del Fichero Creado .............................................................. 96
4.4 Manejo de Ficheros Memoria Externa .......................................................... 96
4.4.1 Creación de Proyecto Fichero2 ................................................................. 97
4.4.2 Permisos Necesarios ...................................................................................... 98
Capítulo 5 – Intentos and services ................................................ 103
5.1 Que son los Intents ............................................................................................... 104
5.2 App EjemploIntents .............................................................................................. 105
5.2.1 Creación de las Cadenas o Constantes .............................................. 106
5.2.2 Manejo de Imágenes .................................................................................... 107
5.2.3 Diseñamos la Interfaz ................................................................................. 107
5.2.4 Manejo de TextView ...................................................................................... 108
5.2.5 Ejecución del proyecto EjemploIntents ............................................ 109
5.2.6 Codificando la Actividad ............................................................................. 110
5.2.7 Volviendo a Ejecutar del proyecto EjemploIntents .................... 115
5.3 App Rutas .................................................................................................................... 117
5.3.1 Diseñamos la Interfaz ................................................................................. 119
5.3.2 Codificamos la Actividad ............................................................................ 119
5.3.3 Ejecución del proyecto EjemploIntents ............................................ 121
Capítulo 6 – Google Maps ............................................................... 124
6.1 Crear un proyecto en la página de Google Developers: .............. 125
6.1.1 Crear proyecto - MiMapa ............................................................................ 130
6.1.2 google_maps_api.xml .................................................................................. 131
2
6.1.3 Indicamos la Clave......................................................................................... 133
6.1.4 Dependencias .................................................................................................... 134
6.1.5 Localización........................................................................................................ 137
6.1.6 Modificamos la Actividad ........................................................................... 138
6.1.8 Adicionando Tipo de Mapas ...................................................................... 140
3
Capítulo 1 - Instalación de
Android Studio
4
1.1 Instalación de Android Studio en Windows
1.1.1 Pre Requisitos
Las Aplicaciones Móviles de este Texto se han creado con Android Studio. Android
Studio incluye Android SDK 5. El prerrequisito para Android Studio es Java JDK
para lo cual seguimos lo siguientes Pasos:
1.- Ingrese a la siguiente URL para descargar el JAVA JDK
http://www.oracle.com/technetwork/java/javase/downloads/index.html
Presione clic en JDK
5
Aceptamos el acuerdo de Licencia
Descargamos JDK para 64 bits de Windows
Luego de descargarlo lo Instalamos
6
1.1.2 Inicio de la Instalación de Android Studio
Para descargar la última versión para Windows de Android Studio puede
descargar de la siguiente URL:
http://developer.android.com/sdk/installing/studio.html
A continuación, ingresara a la siguiente pantalla y presionara clic en el botón
Download Android Studio for Windows
Acepte las condiciones y comience la descarga
7
Espere que concluya la descarga:
Una vez realizada la descarga, proceder a instalar, En Windows ejecute el archivo EXE:
8
Presionar el Botón Next (Siguiente):
9
Presionar el Botón Install (Instalar):
10
11
Presionar el Botón Finish (Finalizar):
Presionar el Botón Ok:
12
Espere que cargue:
13
14
15
16
1.2 Configuración del Android Studio
El paquete de Android Studio descargado incluye el último Android SDK. Antes
de empezar con tu primer proyecto Android, se debe configurar Android Studio.
Para ello debemos presionar clic en Configure:
17
Luego debemos seleccionar en que versiones del sistema operativo se dará soporte por ejemplo deseo dar soporte a la versión
4.X y luego presiones el botón Install:
18
Espere que finalice:
Recomendamos dar soporte a versiones antiguas según la

estadística de versiones
19
1.3 Instalación de Android Studio En OS X
Mac® OS X® 10.8.5 o superior 10.9 (Mavericks), Recomendable 10.9.4:
2 GB RAM minimum, 4 GB RAM Recommendable
400 MB Espacio de Disco Duro
1280 x 800 mínimo de resolución
Descargar Java Runtime Environment (JRE) 6, del siguiente Link:
http://www.oracle.com/technetwork/java/javase/downloads/jre7-
downloads-1880261.html
Java Runtime Environment (JRE) 6, del siguiente Link:
20
Opcionalmente acelerador emulador: Intel® VT-x, Intel® EM64T (Intel® 64)
Es necesario verificar la instalación del JDK, mediante el terminal
Inicio de la Instalación de Android Studio, Descargarnos del siguiente Link

Android Studio para Mac:http://developer.android.com/sdk/index.html
Lo arrastramos a la carpeta de aplicaciones:
21
Inicio de la Instalación de Android Studio, Descargarnos del siguiente Link
Android Studio para Mac:http://developer.android.com/sdk/index.html
Otros Sistemas Operativos – Linux
• GNOME or KDE desktop

• Tested on Ubuntu® 14.04 LTS, Trusty Tahr (64-bit distribution capable of
running 32-bit applications)
• 64-bit distribution capable of running 32-bit applications
• GNU C Library (glibc) 2.19 or later
• 3 GB RAM minimum, 8 GB RAM recommended; plus 1 GB for the Android
Emulator
• 2 GB of available disk space minimum,
• 4 GB Recommended (500 MB for IDE + 1.5 GB for Android SDK and
emulator system image)
• 1280 x 800 minimum screen resolution
22
1.4 Otras Opciones de Descarga
1.5 Algunas Recomendaciones al Utilizar El Emulador
En algunas oportunidades existe inconvenientes en la ejecución del emulador

para ello deberá verificar lo siguiente:
1.5.1 Activar en la Bios Tecnologia de Virtualización
23
1.5.2 Instalación IntelHaxm.exe
Ubicado en la siguiente Carpeta:
[Android SDK Root] \ extras \ intel \
Hardware_Accelerated_Execution_Manager
24
Capítulo 2 - Creación de
Mi Primera App
25
2.1 Creando la Primera Aplicación
Ante de crear la primera App describiremos las distintas opciones:
26
Menú de Ayuda:
27
Para comenzar a crear un nuevo proyecto haga clic en Start a new Android Studio Project (Inicie un nuevo proyecto Android
Studio):
28
Ahora elegimos usar actividad en Blanco y luego presionamos el botón Next
(Siguiente):
Ahora comenzamos a crear el proyecto indicando los siguientes datos y luego

presionamos el botón Finish (Finalizar):
29
Más sobre elección de su tipo de actividad
Este paso le permite crear la actividad principal de su aplicación, entre los

diferentes tipos de actividad tenemos los siguientes:
Basic Activity: Esto crea una actividad en
blanco con un botón Flotantes
Bottom Navigation Activity: Esto crea

una actividad con una barra de navegación
inferiores facilitan la exploración y el
cambio entre las vistas de nivel superior
con un solo toque.
Empty Activity: Esto crea una actividad

en blanco con una barra de acción. La
barra de acción incluye un título y un menú
de opciones.
Fragment + ViewModel:
La ViewModelclase está diseñada para
almacenar y administrar datos
relacionados con la IU en una forma
consciente del ciclo de
vida. La ViewModelclase permite que los
datos sobrevivan a cambios de
configuración, como rotaciones de
pantalla.
30
Google AdMob Ads Activity : esta
plantilla utiliza AdMob como un servicio de
Google para integrar anuncios en tus
aplicaciones Android, con el fin de
monetizar la actividad de tu audiencia a
través de redes de publicidad (ad
networks).
Fullscreen Activity: Esta plantilla oculta

la interfaz de usuario del sistema (tales
como la barra notificación) en una vista de
pantalla completa. El modo de pantalla
completa se alterna con una barra de
acción que aparece cuando el usuario toca
la pantalla del dispositivo.
Google map activity: Esta

plantilla Activity de Google Maps te ayuda
a reducir el proceso para incluir en
nuestra aplicación la API de Google Maps
Android.
Login activity: Esta plantilla crea su vista

como una pantalla de conexión o
validación que permite a los usuarios
iniciar sesión o registrarse con una
dirección de correo y contraseña.
31
Master/Detail Flow: Esta plantilla divide
la pantalla en dos partes: a la izquierda
menú y los detalles del elemento
seleccionado a la derecha. En una pantalla
más pequeña, Se muestra sólo una
sección, pero en una pantalla más grande,
ambas secciones son visualizados al
mismo tiempo
Navigation Drawer Activity : Esto crear

una actividad con un panel lateral de
navegación es un panel en el que se
muestran las principales opciones de
navegación de la app en el borde izquierdo
de la pantalla. La mayor parte del tiempo
está oculto, pero aparece cuando el
usuario desliza un dedo desde el borde
izquierdo de la pantalla o, mientras está
en el nivel superior de la app, el usuario
toca el ícono de la app en la barra de
acciones.
El Scrolling Activity : Esto crea una
actividad con una interfaz donde se
expone un título llamativo con una imagen
y seguido a este un contenido desplazable
Settings Activity: Esto crea una

actividad de preferencia con una lista de
ajustes.
Tabbed Activity : Esto crea una actividad

con una serie de pestañas.
32
2.1.1 Conociendo el Entorno de Trabajo
33
2.1.2 Conociendo la Estructura del Proyecto
Al crear un proyecto en Android Studio la estructura del proyecto será diferente a la creada con eclipse. Esta nueva estructura
es por el cambio de Ant a Gradle es más dinámica y flexible, a continuación, explicaremos la misma pero previamente
cambiamos a modo proyecto:
34
Desarrollo de Aplicaciones con Android
Primero comenzamos explicando algunas carpetas del proyecto que a
continuación observamos:
35
Expandimos la carpeta src (source o código fuente):
Se recomienda la utilización de Android Asset Studio

que te permite la generación de bitmaps para las
interfaces:
http://romannurik.github.io/AndroidAssetStudio/
36
Ahora examinamos la carpeta res:
Ahora examinamos la carpeta res – value:
37
2.1.3 Archivo colors.xml
En este recurso XML almacenaremos todos los colores en su valor

hexadecimal que usaremos en nuestra aplicación. Deben ser
almacenados en el fichero “res/values/colors.xml”.
2.1.4 Archivo strings.xml

En este archivo se almacenará las cadenas constantes.
Archivo XML que define cadenas de texto usadas en la

aplicación. Por ejemplo, para colocar los títulos de las
ventanas o el nombre de la aplicación y referenciarlas
cuando lo nececesites en el código
38
2.1.5 Archivo styles.xml
Archivo XML que define los estilos usados en la Apps. Estos

estilos pueden ser aplicados a los elementos de la interfaz de
usuario, de modo que separamos la plantilla de las
funcionalidades. Lo cual hace nuestra aplicación más fácil de
mantener.
2.1.6 Archivo de Manifiesto o Configuración de Nuestra App
Todas las aplicaciones deben tener un archivo AndroidManifest.xml (con ese

nombre exacto) en el directorio raíz. El archivo de manifiesto proporciona
información esencial sobre tu aplicación al
sistema Android, información que el sistema
debe tener para poder ejecutar el código de la
app.
Entre otras cosas, el archivo de manifiesto hace
lo siguiente:
• Nombra el paquete de Java para la
aplicación. El nombre del paquete sirve
como un identificador único para la
aplicación.
• Describe los componentes de la
aplicación, como las actividades, los servicios, los receptores de mensajes
39
y los proveedores de contenido que la integran. También nombra las clases
que implementa cada uno de los componentes y publica sus capacidades,
como los mensajes Intent con los que pueden funcionar. Estas
declaraciones notifican al sistema Android los componentes y las
condiciones para el lanzamiento.
• Determina los procesos que alojan a los componentes de la aplicación.
• Declara los permisos debe tener la aplicación para acceder a las partes
protegidas de una API e interactuar con otras aplicaciones. También
declara los permisos que otros deben tener para interactuar con los
componentes de la aplicación.
• Enumera las clases Instrumentación que proporcionan un perfil y otra
información mientras la aplicación se ejecuta. Estas declaraciones están
en el manifiesto solo mientras la aplicación se desarrolla y se quitan antes
de la publicación de esta.
• Declara el nivel mínimo de Android API que requiere la aplicación.
• Enumera las bibliotecas con las que debe estar vinculada la aplicación.
Teoría Sobre el Manifiesto
1. Nombra el paquete de Java para la aplicación. El nombre del paquete sirve

como un identificador único para la aplicación.
2. Describe los componentes de la aplicación, como las actividades, los

servicios, los receptores de mensajes y los proveedores de contenido que
la integran. También nombra las clases que implementa cada uno de los
componentes y publica sus capacidades, como los mensajes Intent con los
que pueden funcionar. Estas declaraciones notifican al sistema Android los
componentes y las condiciones para el lanzamiento.
3. Determina los procesos que alojan a los componentes de la aplicación.
4. Declara los permisos debe tener la aplicación para acceder a las partes
protegidas de una API e interactuar con otras aplicaciones. También
declara los permisos que otros deben tener para interactuar con los
componentes de la aplicación.
5. Enumera las clases Instrumentación que proporcionan un perfil y otra

información mientras la aplicación se ejecuta. Estas declaraciones están
en el manifiesto solo mientras la aplicación se desarrolla y se quitan antes
de la publicación de esta.
6. Declara el nivel mínimo de Android API que requiere la aplicación.
7. Enumera las bibliotecas con las que debe estar vinculada la aplicación.
40
Este archivo se genera automáticamente y se declara

información básica como: Nombre Paquete, Actividades,
Estilos, iconos,permisos, etc.
41
AndroidManifest.xml
42
2.1.7 Archivo Gradle

Gradle es un sistema de construcción de App a través de plugins, a continuación, mostramos su estructura:
43
2.1.8 En Otros Archivos Importantes:

local.properties
Archivo que establece la ubicación del SDK
44
2.1.9 Conociendo la Interfaz

Ahora comenzaremos a conocer más sobre la Interfaz:
45
2.1.10 Ejecutando la Aplicación

Ahora para ejecutar la App podemos hacerlo utilizando el emulador o un
dispositivo físico recomiendo usar un dispositivo físico para ello procedemos a
conectar nuestro dispositivo o celular. Hecho esto seguimos los siguientes pasos:
Presione el botón Run
Ahora indicamos si utilizamos un dispositivo físico o un emulador:
Se recomiendo utilizar un dispositivo físico
46
Emulador en acción:
47
2.1.11 Captura de Pantalla

Usted puede observar la ejecución de su App presionando el siguiente botón (Captura de Pantalla):
48
2.2 Creando Apps – Lector Codigo Barras

Ante de crear la primera App describiremos las distintas opciones:
49
Para comenzar a crear un nuevo proyecto haga clic en Start a new Android Studio Project (Inicie un nuevo proyecto Android
Studio):
50

(Siguiente):

51
2.2.1 Obtenemos lo siguiente
52
2.2.2 Biblioteca de escaneo

Hacemos referencia a la Biblioteca de escaneo de código de barras para Android, utilizando ZXing para decodificación:
53
2.2.3 Diseñamos la Interfaz
54
2.2.4 Codificación de la Actividad
55

Ahora indicamos si utilizamos un dispositivo físico o un emulador:
Se recomiendo utilizar un dispositivo físico
56
57
58
Capítulo 3 – Manejo de
Controles
59
3.1 App Suma
Vamos a Desarrollar una App que ayuda que realice la suma de dos numeros, como ya hemos creado la primera App obviamos
los pasos de crear la App Suma.
Borramos el TextView para comenzar con una interfaz limpia:
60
Vamos a crear una App de suma de 2 números que tendrá por objetivo la utilización de controles básicos, Necesitamos dos
etiquetas (TextView), dos textos editables donde ingresaremos los numero a sumar ( EditText) y dos Buttons que a
continuación mostramos:
Esto permite externalizar valores de propiedades como cadenas de texto de forma

sencilla en ficheros XML de recursos. Por defecto, en un proyecto Android se crea
dentro de “res > values” un fichero strings.xml en el cual se localizan cadenas de texto
reutilizables desde cualquier punto del proyecto.
61
Lo primero que Debemos hacer es eliminar el TextView, los seleccionamos –
presionamos clic derecho - delete
Ahora recomendamos crear algunas constantes para definir el contenido de los
textviews, buttons Primero Crearemos un Textview:
Al comenzar a crear el primer TextView no se olvide de colocar márgenes

Esto permitirá posicionar el control en el lugar designado:
62
Ahora comenzamos a trabajar con las propiedades de textview:
Propiedad text:
63
De la misma manera crear el segundo textview con el contenido “Introduzca el
segundo Número”
Ahora crearemos dos editText
64
Ahora comenzamos a trabajar con las propiedades de editText:

Propiedad id
Id es la propiedad que representa el identificador o nombre del control:
65
Propiedad inputType
Utilizamos esta propiedad para que solo nos permita ingresar números:
66
Ahora creamos un TextView donde mostramos el resultado de la suma
Ahora manipularemos algunas propiedades del TextView:
No se olvide de los márgenes:
67
Ahora crearemos dos Buttons
68
No se olvide de los márgenes:

Ahora indicamos si utilizamos un dispositivo físico o un emulador y presionamos el botón

Ok
69
Obtenemos lo siguiente:
OJO SI UTILIZA EL EMULADOR, UNA VEZ CARGADO EL EMULADOR

NO LO CIERRE , VUELVA A UTILIZARLO PARA AHORRA TIEMPO Y
RECURSOS
70
3.1.2 Algo de Teoria - Actividad

Antes de comenzar a codificar definamos algunos conceptos: En Android, una
actividad es una ventana que contiene la interfaz de usuario (pantalla) para su
aplicación y los usuarios interactuar directamente con las actividades de sus
aplicaciones. La actividad es el componente más habitual de las aplicaciones para
Android. Un componente Activity refleja una determinada actividad llevada a cabo
por una aplicación, y que lleva asociada típicamente una ventana o interfaz de
usuario.
3.1.3 Codificando la Aplicación Suma

Antes de comenzar a codificar definamos algunos conceptos:
En Android, una actividad es una ventana que contiene la interfaz de usuario
(pantalla) para su aplicación y los usuarios interactuar directamente con las
actividades de sus aplicaciones.
La actividad es el componente más habitual de las aplicaciones para Android. Un

componente Activity refleja una determinada actividad llevada a cabo por una
aplicación, y que lleva asociada típicamente una ventana o interfaz de usuario.
Descripción de la Activity MainActivity

Una vez finalizado el diseño procedemos a comenzar con la codificación:
71
Una vez finalizado el diseño procedemos a comenzar con la codificación:
72
Ahora comenzamos codificando creando algunas variables que serán necesarias para hacer referencia a los objetos de la
interfaz:
73
3.1.4 Algo de Teoria - Bundle

Una forma de guardar datos cuando se destruye una actividad es a través del
Bundle. Esto es exactamente como la intención que usaste antes, ya que
guarda los datos en pares clave / valor. Vamos a establecer cómo funciona el
paquete.
Eche un vistazo al método onCreate nuevamente. La primera línea del método
es esta:
protected void onCreate( Bundle savedInstanceState )
La parte Bundle es un tipo, al igual que Int o String es un tipo. Pero este tipo
maneja las claves y sus valores. La parte savedInstanceState es solo un
nombre de variable.
Puede llamar a varios métodos en su nombre de Bundle. Uno de estos métodos

es putInt . Otro es putString . Estos métodos se usan para poner datos en un
par clave / valor. Queremos guardar un valor entero, así que podríamos usar
esto:
savedInstanceState.putInt ("HIGH_SCORE", someScore);
74
3.1.5 Continuando con la Codificando la Aplicación Suma

Ahora comenzamos codificando creando algunas variables que serán necesarias para hacer referencia a los objetos de la
interfaz
75
Ahora obtenemos referencia a cada uno de los elementos de nuestra interfaz mediante el método findViewById :
76
3.1.6 Implementar el escucha de eventos

Los eventos los encontramos en muchos lenguajes de programación, para ello en Android tenemos disponibles un gran numero
distinto de eventos que podemos tener, desde el touch o clicks, hasta eventos generados por movimientos en un acelerómetro,
termómetro u otros sensores de los dispositivos Android.
podemos implementar uno de los eventos más simples, el OnClickListener, para escuchar eventos de clics realizados sobre un
botón.
public class MainActivity extends AppCompatActivity implements

View.OnClickListener {
77
3.1.6.1 Implementamos la escucha de eventos I
78
3.1.6.2 Implementamos la escucha de eventos II
79
3.1.6.3 Implementamos la escucha de eventos III
80
3.1.6.4 Implementamos la escucha de eventos IV
3.1.6.5 Método onClick
81
3.1.6.6 Implementamos la escucha de eventos de Botones
82
3.1.6.7 Implementamos la codificación
83
3.1.7 Ahora volvemos a ejecutar la Apps Suma:
84
3.1.8 Utilizando Lambda:
85
3.1.9 Cambios necesarios en el Gradle- Lambda:
86
3.1.10 Volviendo a Ejecutar la Aplicación Suma

Ahora indicamos si utilizamos un dispositivo físico o un emulador y presionamos

el botón Ok
Obtenemos lo siguiente:
87
Capítulo 4 –
Almacenamiento
88
4.1 Introducción a Manejo de Ficheros
Vamos a aprender a manipular ficheros almacenados en cualquiera de estos

lugares, comentando las particularidades de cada caso:
• La memoria interna del dispositivo.
• La tarjeta SD externa, si existe.
• La propia aplicación, en forma de recurso
4.2 Almacenamiento
Almacenamiento y Content Providers Base de datos SQLite: consulta, inserción,
actualización, eliminación de datos. Shared Preferences. Procesamiento de XML.
Content Providers: Llamadas, Contactos y SMS
4.3 Manejo de Ficheros Memoria Interna
4.3.1 Memoria Interna-WRITE
Veamos en primer lugar cómo trabajar con la memoria interna del
dispositivo.
Cuando almacenamos ficheros en la memoria interna debemos tener en cuenta
las limitaciones de espacio que tienen muchos dispositivos, por lo que no
deberíamos abusar de este espacio utilizando ficheros de gran tamaño.
openFileOutput()
MODO DE ACCESO:
MODE_PRIVATE(por defecto) para acceso privado desde nuestra aplicación,
MODE_APPEND para añadir datos a un fichero ya existente,
MODE_WORLD_READABLE para permitir a otras aplicaciones leer el fichero,
MODE_WORLD_WRITABLE para permitir a otras aplicaciones escribir sobre el
fichero
try
{
OutputStreamWriter fout=
new OutputStreamWriter(
openFileOutput(«Nombre del archivo», Context.MODE_PRIVATE));
fout.write(«Escribir o enviar texto para el archivo»); fout.close();
}
catch (Exception ex)
{
Log.e("Ficheros", "Error al escribir fichero a memoria interna");
}
4.3.2 Creación de Proyecto Fichero1
Puedes guardar archivos directamente en el almacenamiento interno del
dispositivo. De forma predeterminada, los archivos que se guardan en el
89
almacenamiento interno son privados para tu aplicación y otras aplicaciones no
pueden tener acceso a ellos (tampoco el usuario). Cuando el usuario desinstala
tu aplicación, estos archivos se quitan
Vamos a crear un proyecto que me permita el almacenamiento interno, como ya
hemos creado proyecto anteriormente, obviamos los pasos de crear Fichero1:
90
Lo primero es crear los controles necesarios:
Comenzamos a codificar:
91
Enlazamos las variables con los controles
Implementamos la escucha de eventos:
92
Ahora codificamos según la acción:
93
Código Completo de la actividad:
94
4.3.3 Ejecución del proyecto Fichero1

Ahora probamos la ejecución mediante el emulador para ello es necesario
seguir los siguientes pasos:
95
4.3.4 Observación del Fichero Creado
4.4 Manejo de Ficheros Memoria Externa
Los teléfonos Android suelen disponer de memoria adicional de almacenamiento,

conocido como almacenamiento externo. Este almacenamiento suele ser de
mayor capacidad, por lo que resulta ideal para almacenar ficheros de música o
vídeo. Suele ser una memoria extraíble, como una tarjeta SD, o una memoria
interna no extraíble (algunos modelos incorporan los dos tipos de memoria, es
decir, almacenamiento externo extraíble y almacenamiento interno no extraíble).
Cuando conectamos el dispositivo Android a través del cable USB permitimos el
96
acceso a esta memoria externa, de forma que los ficheros aquí escritos podrán
ser leídos, modificados o borrados por cualquier usuario.
Como sabemos esta memoria puede estar presente como no o en ciertos casos
pueden estar, pero no ser reconocida, para ello procederemos a validar.
Ahora veremos cómo utilizar el método getExternalStorageStatus(), este es un
método estático de la clase Environment.
Este método devuelve una serie de valores siendo los más importantes:
• MEDIA_MOUNTED, que indica que la memoria externa está disponible y
podemos tanto leer como escribir en ella.
• MEDIA_MOUNTED_READ_ONLY, que indica que la memoria externa está
disponible, pero sólo podemos leer de ella.
4.4.1 Creación de Proyecto Fichero2
Vamos a crear un proyecto que me permita el almacenamiento interno, como
ya hemos creado proyecto anteriormente, obviamos los pasos de crear
Fichero2:
97
4.4.2 Permisos Necesarios

Ahora debemos dar permisos a nuestro proyecto de acceso en la memoria externa, para
ello abrimos el archivo de manifiesto y agregamos la siguiente línea:
98
Lo primero es crear los controles necesarios:
Comenzamos a codificar:
99
Enlazamos las variables con los controles
Implementamos la escucha de eventos:
100
Codificamos las diferentes opciones:
101
102
Capítulo 5 – Intentos and

services
103
5.1 Que son los Intents
Los Intents son conocidos como el mecanismo de paso de mensajes entre una
Actividad a otra que puede trabajar entre nuestras propias Actividades o entre
diferentes Aplicaciones (Bastante importante). Los Intents puede ser utilizados
como:
1. Declara la intención de una Actividad o Servicio que va ser iniciada al

realizar una acción.
2. Difundir que un evento ha ocurrido
3. Iniciar un Servicio en particular o una actividad.
Uno de los usos más comunes de los Intentos es iniciar nuevas Actividades,
Explícitamente (Cuando se especifica la clase a cargar) o Implícitamente (por una
solicitud de que una acción va ser realizada sobre unos datos específicos).
104
Los Intents, también puede ser utilizados como emisores o comunicadores
(broadcast) de eventos a través del sistema. Cualquier aplicación puede registrar
este tipo de Emisiones o Eventos y reaccionar por medio de los Intents.
Por ejemplo, los Intents pueden anunciar eventos del sistema como el cambio de
estado en la conexión de internet o el nivel de batería. Aplicaciones nativas de
Android como el marcador del teléfono (Phone Dialer) o el SMS messeger
registran componentes para escuchar eventos específicos como una llamada
entrante o un mensaje SMS recibido.
Después de haber creado la primera aplicación para Android, ahora para crear un
nuevo proyecto se puede crear seleccionando Archivo - Nuevo - Android proyecto,
el nombre de proyecto: Ejemplo_Intents (los pasos de creación de un proyecto
ya se detallaron en ejemplos anteriores)
5.2 App EjemploIntents
Crear una aplicación que permita demostrar el uso de intents invocando a:
1. Una URL
2. Youtube
3. Calculadora
4. Camara
105
5.2.1 Creación de las Cadenas o Constantes

Para nuestra aplicación crearemos las siguientes cadenas o constantes:
106
5.2.2 Manejo de Imágenes

Copiamos las imágenes en la carpeta: drawable
107
5.2.4 Manejo de TextView

Creamos los TextView y imageButton:
Asignamos IDs:
108
5.2.5 Ejecución del proyecto EjemploIntents

Obtenemos lo siguientes:
109
5.2.6 Codificando la Actividad

Comenzamos la codificación en la actividad:
Declaramos las variables necesarias:
110
Enlazamos variables con controles:
Escucha de eventos:
111
Implementación de Escucha de eventos:
112
113
Procedemos a la Codificación en el método onclick:
Código de llamada a una URL:
Código de llamada a YOUTUBE:
114
Código de llamada a la CAMARA:
5.2.7 Volviendo a Ejecutar del proyecto EjemploIntents

Ahora probamos la ejecución mediante el emulador para ello es necesario seguir
los siguientes pasos:
115
116
5.3 App Rutas
Crear una aplicación que permita demostrar el uso de intents construyendo la

ruta hacia un destino final
Para comenzar a crear un nuevo proyecto haga clic en Start a new Android Studio
Project (Inicie un nuevo proyecto Android Studio):
117
(Siguiente):

118
5.3.2 Codificamos la Actividad
119
Detalle de la codificación:
package com.inkadroid.rutas;
import android.content.Intent;
import android.net.Uri;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import android.widget.EditText;
public class MainActivity extends
AppCompatActivity implements View.OnClickListener
{
private Button btnIr;
private EditText edtFinal;
@Override
protected void onCreate(Bundle
savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
edtFinal=(EditText)
findViewById(R.id.edtFinal);
btnIr=(Button) findViewById(R.id.btnIr);
btnIr.setOnClickListener(this);
}
@Override
public void onClick(View v) {
switch (v.getId())
{
case R.id.btnIr:
Intent geoIntent = new Intent
(android.content.Intent.ACTION_VIEW, Uri.parse
("geo:0,0?q=" +
edtFinal.getText().toString().trim()));
startActivity(geoIntent);
break;
}
}
}
120
5.3.3 Ejecución del proyecto EjemploIntents

121
122
123
Capítulo 6 – Google Maps
124
6.1 Crear un proyecto en la página de Google Developers:
A continuación, se mostrará la creación de un proyecto de mapas en eclipse y

Android studio.
Para poder desarrollar aplicativos de este tipo es necesario ingresar a la siguiente
página https://console.developers.google.com/ y ahí creamos un proyecto, para
nuestro caso tendrá el nombre MiMapa:
125
Indicamos el nombre del proyecto y presionamos el botón CREAR:
Observamos los datos del proyecto:
126
Habilitamos el API:
Seleccionamos Maps SDK:
127
Clic en HABILITAR:
CREDENCIALES:
Crear credenciales:
128
Clave de API:
AIzaSyC7YRVUsN5ogxhHQvM7cwOdV_zxVuJtXfs
129
6.1.1 Crear proyecto - MiMapa
Seleccionamos el tipo de actividad:
130
Indicamos el nombre del proyecto:
6.1.2 google_maps_api.xml
Luego de crear el proyecto será necesario copiar el id que se generó en la página
de Google Developer. Abrir el archivo google_maps_api.xml:
131
google_maps_api.xml:
132
6.1.3 Indicamos la Clave

Pegamos la clave obtenida de Google Developer
133
6.1.4 Dependencias
El proyecto generado de esta forma te evita hacer modificaciones en un proyecto básico de Android si es el caso donde existe
ya un proyecto al cual hay que agregarle el Api de Google maps se debe hacer lo siguiente:
En el Archivo build.gradle revise la siguiente dependencia com.google.android.gms:play-services-maps:16.0.0
134
En el AndroidManifest.xml agregamos los permisos y metadatos:
Permisos:
• android.permission.ACCESS_FINE_LOCATION
135
Ejecutamos la aplicación: la posición inicial se da en la latitud y longitud 0,0.
136
6.1.5 Localización
Cambiemos la Geolocalización:
137
Cambiemos la Geolocalización hacia cuzco - Machu Picchu:
6.1.6 Modificamos la Actividad
138
Volvemos a Ejecutar la aplicación: la posición inicial se da en la latitud y longitud:
-13.1631, -72.5450
139
6.1.8 Adicionando Tipo de Mapas

El tipo de mapa depende del tipo de información que necesitan. Cuando use los mapas para navegar en su automóvil, es útil
ver claramente los nombres de las calles. Cuando estás de excursión, es probable que te importe más cuánto tienes que subir
para llegar a la cima de la montaña. En este paso, agrega una barra de aplicaciones con un menú de opciones que le permite
al usuario cambiar el tipo de mapa.
Modificar el archivo strings.xml:
140
Crear la Siguiente Carpeta:
Presione Ok
141
Indicar el nombre de la carpeta:
Crearemos un archivo Android Resource File:
Escriba lo siguiente:
142
Escriba lo siguiente:
143
Editar la actividad modificar lo siguiente:
Añadir los siguientes métodos, luego del constructor:
144
Volvemos a Ejecutar la aplicación: la posición inicial se da en la latitud y longitud:
-13.1631, -72.5450
Mapa Normal
145
Mapa Hibrido
146
Mapa Satelital
147
148

Manual PDF

Cargado por

Copyright:

Formatos disponibles

Manual PDF

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Manual PDF

Cargado por

Copyright:

Formatos disponibles

Contenido

Capítulo 1 - Instalación de Android Studio ....................................... 4

Presione clic en JDK

Descargamos JDK para 64 bits de Windows

Luego de descargarlo lo Instalamos

Acepte las condiciones y comience la descarga

Presionar el Botón Next (Siguiente):

Presionar el Botón Install (Instalar):

Presionar el Botón Ok:

Presionar el Botón Next (Siguiente):

Presionar el Botón Finish (Finalizar):

Recomendamos dar soporte a versiones antiguas según la

Java Runtime Environment (JRE) 6, del siguiente Link:

Inicio de la Instalación de Android Studio, Descargarnos del siguiente Link

Lo arrastramos a la carpeta de aplicaciones:

Otros Sistemas Operativos – Linux

• GNOME or KDE desktop

1.5 Algunas Recomendaciones al Utilizar El Emulador

En algunas oportunidades existe inconvenientes en la ejecución del emulador

Ahora comenzamos a crear el proyecto indicando los siguientes datos y luego

Este paso le permite crear la actividad principal de su aplicación, entre los

Bottom Navigation Activity: Esto crea

Empty Activity: Esto crea una actividad

Fullscreen Activity: Esta plantilla oculta

Google map activity: Esta

Login activity: Esta plantilla crea su vista

Navigation Drawer Activity : Esto crear

Settings Activity: Esto crea una

Tabbed Activity : Esto crea una actividad

Se recomienda la utilización de Android Asset Studio

Ahora examinamos la carpeta res – value:

2.1.3 Archivo colors.xml

En este recurso XML almacenaremos todos los colores en su valor

2.1.4 Archivo strings.xml

Archivo XML que define cadenas de texto usadas en la

2.1.5 Archivo styles.xml

Archivo XML que define los estilos usados en la Apps. Estos

2.1.6 Archivo de Manifiesto o Configuración de Nuestra App

Todas las aplicaciones deben tener un archivo AndroidManifest.xml (con ese

Teoría Sobre el Manifiesto

1. Nombra el paquete de Java para la aplicación. El nombre del paquete sirve

2. Describe los componentes de la aplicación, como las actividades, los

3. Determina los procesos que alojan a los componentes de la aplicación.

5. Enumera las clases Instrumentación que proporcionan un perfil y otra

6. Declara el nivel mínimo de Android API que requiere la aplicación.

Este archivo se genera automáticamente y se declara

2.1.7 Archivo Gradle

2.1.8 En Otros Archivos Importantes:

2.1.9 Conociendo la Interfaz

2.1.10 Ejecutando la Aplicación

Ahora indicamos si utilizamos un dispositivo físico o un emulador:

Se recomiendo utilizar un dispositivo físico

2.1.11 Captura de Pantalla

2.2 Creando Apps – Lector Codigo Barras

Ahora elegimos usar actividad en Blanco y luego presionamos el botón Next

Ahora comenzamos a crear el proyecto indicando los siguientes datos y luego

2.2.1 Obtenemos lo siguiente

2.2.2 Biblioteca de escaneo

2.2.3 Diseñamos la Interfaz