Manual 2015-I 05 - Desarrollo de Aplicaciones Móviles I (1896)

DESARROLLO DE
APLICACIONES
MÓVILES I
DESARROLLO DE APLICACIONES MÓVILES I 2
CARRERAS PROFESIONALES CIBERTEC

Índice
Presentación 05
Red de contenidos 07
UNIDAD 1. ANDROID: INTRODUCCIÓN A LA PLATAFORMA 09
1.1 Plataforma Android 09
1.1.1 Introducción a Android, versiones 11
1.1.2 Características y Arquitectura Android. 13
1.1.3 Máquina virtual Dalvik Virtual Machine y ART 15
1.1.4 Open Handset Alliance 17
1.1.5 Creación de emuladores 17
1.2 IDE Android Studio 18

1.2.1 Android Studio características y funciones. 19
1.2.2 Creando la primera aplicación Hola Mundo. 23
1.2.3 Controles básicos Button, EditText, TextView 25
1.2.4 Depuración de código en Android. 29
Resumen de la unidad 31
UNIDAD 2. ANDROID: COMPONENTES 32

2.1 Fundamentos de aplicaciones Android 34
2.1.1 Arquitectura de la plataforma Android. 35
2.1.2 Estructura de un proyecto Android. 35
2.1.3 Que es un Gradle 43
2.2 Componente de una pantalla: Views y ViewGroups 44

2.2.1 Componente de una pantalla: Views y ViewGroups 44
2.2.2 Distribución de los ViewGroups: LinearLayout, AbsoluteLayout,
TableLayout, Relative Layout, FrameLayout y ScrollView. 45
2.2.3 Widgets 51
2.2.4 Controles básicos Android 51
2.3 Componente Activity e Intent: definición y características 56

2.3.1 Activity 56
2.3.2 Ciclo de vida de la clase activity 58
2.3.3 Introducción a los Intent . 60
2.3.4 Funcionalidad y uso de Intents 61
2.3.5 Resolviendo problemas de pantalla. 63
2.4 Orientación del dispositivo 66

2.4.1 Adaptación de la interface de usuario a la orientación del dispositivo 67
2.4.2 Manejar cambios en la orientación del dispositivo. 68
2.5 Dialogos y notificaciones 69

2.5.1 Notificaciones Toast 70
2.5.2 Notificaciones en la barra de estado. 71
2.5.3 Dialogos personalizados basados en clases. 73
UNIDAD 3. PERSISTENCIA DE DATOS EN ANDROID 84

3.1 Acceso a recursos y archivos 85
3.1.1 Tipos de recursos en Android 86
3.1.2 Almacenamiento privado y compartido. 88
3.1.3 Grabar y cargar datos de Preferencias de Usuario. 89
3.1.4 File, FileOutputStream, OutputStreamWriter, PrintWriter 91
3.1.5 Environment uso de métodos básicos para acceso a recursos. 94
3.2 Persistencia de Datos usando SQLite

3.2.1 Introducción a adaptadores de datos 94
CIBERTEC CARRERA DE ELECTRICIDAD

3.2.2 Introducción a SQLite 96

3.2.3 Gestión de bases de datos con SQLite. Uso del componente
SQLiteOpenHelper. 98
3.2.4 La clase ContentValues 99
3.2.5 Mantenimiento de datos Insert, Update, Delete rawQuery 100
3.3 Aplicando el Modelo Vista controlador con SQLite

3.3.1 Clases de acceso a datos basados en el modelo vista controlador. 102
UNIDAD 4. NETWORKING EN ANDROID

4.1 Consumiendo servicios web
4.1.1 SOAP (Simple Object Access Protocol) Mensajes SOAP, Estructura 104
4.1.2 Uso del protocolo HTTP para consumir web services. 106
4.1.3 Obtención de data de archivos XML. 108
4.1.4 Clases de acceso a web services 115
4.1.5 Thead Manejando hilos 117
UNIDAD 5. Servicios basados en localización

5.1 Manejo de fragments
5.1.1 Que es Fragment 129
5.1.2 Creating a Fragment, administrar Fragments,Flagment class 132
5.1.3 Eventos fragment, Aplicación fragment 131
5.1 Servicios basados en localización

5.1.1 Utilizar Google Maps en la aplicación. 137
5.1.2 Obtención de la localización (coordenadas) del dispositivo. 138
5.1.3 Google Maps 139
5.1.4 Activar las API de Google Maps. 140
UNIDAD 6. SERVICIOS
6.1 Creando y administrando Servicios
6.1.1 Qué es un servicio, 145
6.1.2 Intent Service, Bound Service. 147
6.1.3 Configurar el archivo de manifiesto. 148
6.1.4 Iniciar/Configurar servicios 149
UNIDAD 7. MULTIMEDIA Y PUBLICACIÓN

7.1 Audio, Video y Uso de Dispositivos visuales
7.1.1 Componente Media Player. Definición, características y aplicaciones. 151
7.1.2 Visualización de videos usando la vista Video. 152
7.1.3 Gráficos 2D y Aplicaciones Multimedia 154
7.1.4 Grabación de audio y video: Uso de Intents para grabar video. 155
7.1 Publicación en Google Play

7.1.1 Google Play 156
7.1.2 Generación de APK firmado con el certificado digital. 157
7.1.3 Publicación de la aplicación. 158
Bibliografia del curso 159

Presentación
El Taller de Desarrollo de Aplicaciones Móviles I es un curso que pertenece a la
línea de programación y desarrollo de aplicaciones siendo un curso de
especialidad sólo en la carrera de Computación e Informática. Permite al alumno
iniciarse en la programación de dispositivos móviles bajo el entorno Android studio
que ha sido optimizado para dispositivos móviles con sistema operativo Android.
El manual para el curso ha sido diseñado bajo la modalidad de unidades de

aprendizaje, las que se desarrollan durante semanas determinadas. En cada una
de ellas, hallará los logros, que debe alcanzar al final de la unidad; el tema tratado,
el cual será ampliamente desarrollado; y los contenidos, que debe desarrollar, y
ejercicios necesarios para poner en práctica los conceptos desarrollados en clase.
Por último, encontrará las actividades que deberá desarrollar en cada sesión, que
le permitirán reforzar lo aprendido en la clase.
El curso es práctico y consiste en un taller de programación. En la primera parte

del curso, se revisan las características del sistema operativo Android así como las
funcionalidades básicas con el fin de familiarizar al participante con la forma de
trabajo y la arquitectura de aplicaciones bajo el sistema operativo Android y la
relación que existe con las aplicaciones y/o servicios de google (Google Apps).
Luego, se desarrollan aplicaciones que permitan el manejo del dispositivo móvil
para ingresar, procesar y presentar información haciendo uso de las clases que
proporciona la plataforma de desarrollo Android, luego se desarrollara persistencia
de datos locales como almacenamiento en disco, bases de datos sqlite y en la
nube vía web services, soap, rest. Se concluye con la publicación de aplicaciones
haciendo uso de los servicios de google vía google play.


Red de contenidos
DESARROLLO DE APLICACIONES MÓVILES I
Unidad 1 Unidad 2 Unidad 3 Unidad 4 Unidad 5 Unidad 6 Unidad 7
Android: Android: Networking en Servicios basados Multimedia y

Introducción a Componentes Android en localización publicación
la plataforma
Persistencia
de datos en Servicios
Android


UNIDAD
1
Introducción a la plataforma
LOGRO DE LA UNIDAD DE APRENDIZAJE
Al término de la unidad, el alumno elabora aplicaciones haciendo uso del
entorno de desarrollo Android Studio.
TEMARIO
1.3 Plataforma Android

1.3.1 Introducción a Android, versiones
1.3.2 Características y Arquitectura Android.
1.3.3 Máquina virtual Dalvik Virtual Machine y ART
1.3.4 Open Handset Alliance
1.3.5 Creación de emuladores
1.4 IDE Android Studio

1.4.1 Android Studio características y funciones.
1.4.2 Creando la primera aplicación Hola Mundo.
1.4.3 Controles básicos Button, EditText, TextView
1.4.4 Depuración de código en Android.
ACTIVIDADES PROPUESTAS
 Los alumnos identifican la arquitectura del sistema operativo android.

 Los alumnos hacen uso del IDE principal de desarrollo Android Studio.
 Los alumnos crean la primera aplicación en adnroid y recococen la
diferencia entre un ativity, layout y las vistas básicas.


1.1. INTRODUCCIÓN A LA PLATAFORMA

1.1.1. Plataforma Android
Android es un sistema operativo móvil basado en el kernel 2.6 de Linux Android fue
desarrollado para dispositivos móviles, tabletas,
relojes, televisores automóviles, actualmente es uno
de los sistemas operativos más utilizados en el
planeta. Inicialmente fue desarrollado por Andy Rubin
figura 1, quien funda la compañía Android inc en
estados unidos en Palo anto, posterior a ello google
adquiere completamente la compañía en el año 2005
posterior a ello se crea en grupo de empresas
asociadas que patrocina androi como plataforma libre
para dispositivos móviles y otros.
La desición de estudia el desarrollo de aplicaciones

para esta platadorma es que tiene el mayor potencial
del mercado ya que no solo esta orientado a
dispositivos móviles sino a una aplica gama de
dispositivos con el soporte de google a continuación
se presenta una imagen de los dispositivos Figura 1: Andy Rubin
que soportan Android figura 2 Fuente: http://es.wikipedia.org/wiki/Andy_Rubin
Figura 2: Dispositivos que soportan Android

Fuente: http://www.android.com/
Android esta basado en capas que permiten administrar las funciones básicas de
cualquier equipo movil, en primer lugar tiene aplicaciones estándares como
administrador de contactos, administrador de aplicaciones administrador de drivers,
administrador de mensajes, administrador de archivos, álbum de fotos, administrador
de llamadas configuración todo controlado tu cuenta de gmail google para cualquier
instalación de aplicación se debe realizar por medio de google play. Debajo de ello se
encuentra las librerías nativas para acceso a bases de datos, administración de
recursos, drivers de audio, administrador de sistema, webkit naegador web nativo, etc.
Por el lado de la maquina virtual se encuentra Virtual Dalvik y Art que es una de las
mejoras que fueron creados en octubre del año 2014, después de ello se tiene el
kernel del sistema operativo tal como se puede apreciar en el grafico que se presenta
a continuación.

Figura 3: Dispositivos que soportan Android

Fuente.- Tomado de http://source.android.com/source/index.html
Qué es una Aplicación Android?

Una aplicación desarrollada en androi es un programa que posee una o varias
funciones específicas que lo hacen útil para un motivo. Son equivalentes a cualquier
programa echo para PC con la diferencia que tiene funcionalidades desarrolados para
el celular uno de los limitantes es el tamaño de pantalla y teclado aunque las últimas
versiones de sistemas operativos tiene soporte a conectar teclado usb.
Por otro lado cualquier aplicación se debe instalar por medio de google play, sin
embargo se puede instalar una aplicación configurando instalar aplicaciones de
fuentes no seguras por otro lado la plataforma Android tiene una gran cantidad de
aplicaciones con mas de 700 mil aplicaciones que se pueden descargar muchos de
ellos gratuitos
Figura 4: Programas posibles para instalar en el celular

Fuente.- Tomado de http://www.androidexperto.com

1.1.2 Características y Arquitectura Android

Una aplicación desarrollada en androi es un programa que posee una o varias
funciones específicas que lo hacen útil para un motivo. Son equivalentes a
cualquier programa
El sistema operativo Android, al igual que los propios teléfonos móviles, ha

evolucionado rápidamente, acumulando una gran cantidad de versiones, desde
la 1.0 para el QWERTY HTC G1, hasta la 4.0 que acaba de salir al mercado.
Entre las principales características tenemos:
 framework de aplicación que habilita la reutilización y reemplazo de

componentes
 máquina virtual dalvik optimizada para móviles
 navegador integrado basado en webkit
 gráficos optimizados por una librería gráfica 2d propia; gráficos 3d

basados en la especificación opengl es 1.0
 sqlite para almacenamiento de datos estructurados

 soporte para gran variedad de archivos multimedia (mpeg4, h.264, mp3,
aac, amr, jpg, png, gif)
 Telefonía gsm
 Bluetooth, edge, 3g y wifi (4g, wimax,…)
 Cámara, gps, compás, acelerómetro,…
 Entorno de desarrollo completo incluyendo emulador, herramientas de
depuración, profiling de memoria y rendimiento y plugin para el ide
eclipse
Competidores comunes
 Apple
o iPhone OS
 RIM
o Blackberry
 Microsoft
o Windows Mobile 6.5 Phone 7 Series
 Symbian Foundation
o Symbian OS
 Palm

o WebOS
Cupcake: Android Version 1.5

Características: Widgets, teclado QWERTY virtual, copy & paste, captura de
vídeos y poder subirlos a Youtube directamente.
Donut: Android Version 1.6 Características: Añade a la anterior la mejoría de

la interfaz de la cámara, búsqueda por voz, y navegación en Google Maps.
Eclair: Android Version 2.0/2.1

Características: Mejoras en Google Maps, salvapantallas animado, incluye
zoom digital para la cámara, y un nuevo navegador de internet.
Froyo: Android Version 2.2

Características: Incluye hostpot Wifi, mejora de la memoria, más veloz,
Microsoft
Exchange y video-llamada.
Ginger Bread: Android Version 2.3

Características: Mejoras del consumo de batería, el soporte de vídeo online y el
teclado virtual, e incluye soporte para pagos mediante NFC2
Honey Comb: Android Version 3.0/3.4

Características: Mejoras para tablets, soporte Flash y Divx, integra Dolphin,
multitarea pudiendo cambiar de aplicación dejando las demás en espera en
una columna, widgets y homepage personalizable.
Ice Cream Sandwich: Android Version 4.0

Características: Multiplataforma (tablets, teléfonos móviles y netbooks), barras
de estado, pantalla principal con soporte para 3D, widgets redimensionables,
soporte usb para teclados, reconocimiento facial y controles para PS3.
Android - 4.4 KitKat
Android - 5.0 Lollipop

Introduce la nueva plataform en base de diseño el nuevo concepto de
Diseño Material (Material Design) y es la primera versión que integra
Android Runtime (ART) de manera predeterminada

1.1.3 Máquina virtual Dalvik Virtual Machine y ART
Dalvik Vrtual Machine

Dalvik es la máquina virtual que utiliza la plataforma para dispositivos
móviles Android. Dalvik ha sido diseñada por Dan Bornstein con contribuciones
de otros ingenieros de Google.
La Máquina Virtual Dalvik (DVM) permite ejecutar aplicaciones programadas
en Java. La DVM no afirma ser una máquina virtual de java (JVM) debido a que
le ocasionaría problemas de licenciamiento, sin embargo cumple ese propósito.
La mayoría de los programas escritos en Java 5 pueden correr sobre la DVM.
DVM sacrifica la portabilidad que caracteriza a Java para poder crear
aplicaciones con un mejor rendimiento y menor consumo de energía, estas dos
características son extremadamente importantes en dispositivos móviles,
debido a que la capacidad de las baterías en estos dispositivos es limitada.
DVM está optimizada para requerir poca memoria y está diseñada para permitir
ejecutar varias instancias de la máquina virtual simultáneamente, delegando en
el sistema operativo subyacente el soporte de aislamiento de procesos, gestión
de memoria e hilos.
Figura 7: Arquitectura de android

Fuente.- Tomado de http://santiagosolisvidal.blogspot.com/2012/08/arquitectura-de-android.html
A menudo Dalvik es nombrada como una máquina virtual Java, pero esto no es
estrictamente correcto, ya que el bytecode con el que opera no es Java

bytecode. Sin embargo, la herramienta dx incluida en el SDK de Android

permite transformar los archivos Class de Java compilados por un compilador
Java al formato de archivos Dex.
El nombre de Dalvik fue elegido por Bornstein en honor a Dalvík, un pueblo
de Eyjafjörður, Islandia, donde vivieron antepasados suyos.
Fuente: http://es.wikipedia.org/wiki/Dalvik
Android Runtime (ART)
Esta maquina virtual permite que las aplicaciones se compilen en código nativo, lo cual
ayuda a que las aplicaciones se carguen más rápido y que traiga el soporte de
procesadores de 64 bits. Google dice que con ART se estima que el desempeño
mejore cuatro veces.
 Android Lollipop te permite configurar rápidamente tu nuevo dispositivo. Usando

NFC, podrás migrar tus cuentas con sólo unir tu nuevo dispositivo con el viejo.
 En el Nexus 6 y Nexus 9, el comando de voz de "OK Google" funciona hasta
cuando la pantalla está apagada.
 Permitirá restablecer la configuración de fábrica y borrar todos los datos de
manera remota, especialmente diseñado para esas ocasiones en las que
perdemos los teléfonos o nos lo roban.
 Los nuevos dispositivos vienen con la encriptación automática activa para
proteger tu información en el caso de que te roben o pierdas el dispositivo.
 Menor latencia en la entrada de sonido permite que la música y los apps de
comunicaciones ofrezcan una mejor experiencia con mayor fluidez.
 Soporte de accesorios de sonido a través de USB.
 Funciones de fotografía profesional, incluyendo la captura completa de cuadros a
cerca de 30 cuadros por segundo, soporte de formatos Bayer RAW y YUV, control
del sensor, lente y flash individualmente por cada cuadro, y la captura de
metadata como modelos de ruido y información óptica.
 Protocolo más eficiente en el consumo de energía para buscar dispositivos de
Bluetooth LE y los contadores (beacons).
 Soporte para 15 nuevos idiomas para incrementar el soporte a más de 68
idiomas.
Fuente: http://www.cnet.com/es/analisis/google-android-5-0-lollipop/

1.1.4 Open Handset Alliance
Es una alianza de empresas de manera comercial para patrocionar el desarrollo de

Android hay 84 compañias que patrocinan el producto en beneficio de continuar
mejorando la plataforma Android. Al gunos de sus miembros son Google, HTC, Dell, Intel,
Motorola, Qualcomm, Texas Instruments, Samsung, LG, T-Mobile, Nvidia y Wind River
Systems.
Figura 4: Lista de empresas open HandSet Alliance

Fuente.- Tomado de http://2.bp.blogspot.com/
1.1.5 Creación de emuladores

Para iniciar en el desarrollo de aplicaciones móviles con Android es necesario tener un
emulador, un emulador es una aplicación que simula ser un equipo físico para ello
debemos hacer uso del administrador de maquinas virtuales. Para ello se debe hacer
clic en el administrador de maquinas virtuales
En la pantalla se debe elegir una de los dispositivos y posterior a ello se debe

descargar los drivers y/o librerías que sean necesarios.

Para más detalles debes continuar con el material de la practica dirigida N° 1
Tema 2: IDE Android Studio
Android Studio, es el IDE (Entorno de desarrollo integrado) que utilizaremos para crear
nuestras aplicaciones es un ide mejorado al que se tenia de eclipse, esta basado en
IntelliJ IDEA de JetBrains para facilitar la generación de código para los
desarrolladores de android esta disponible para plataforma windows, MAC O/S y linux.
Para descargar el ide android studio puedes ingresar al siguiente link:

http://developer.android.com/sdk/index.html
Lo más resaltante de androidstudio es la ayuda integrada

Figura 9: Intelligent code editor

Fuente.- Tomado de http://developer.android.com/sdk/index.html
1.2.1 Android Studio características y funciones.
 Sistema de construcción de código basado en JetBrains flexible.

 Construir variantes y generación de archivos apk múltiple
 Plantillas de código para ayudarle a construir características de la aplicación
comunes
 editor de diseño Rich con soporte para arrastrar y soltar de edición tema
 Herramientas de pelusa para atrapar el rendimiento, facilidad de uso ,
compatibilidad de versiones , y otros problemas
 Capacidades ProGuard y aplicación de firma
 El soporte integrado para la plataforma de nube Google , por lo que es fácil de
integrar Google Cloud Mensajería y App Engine
 Soporte para construcción basada en Gradle.
 Consola de desarrollador: consejos de optimización, ayuda para la traducción,
estadísticas de uso.
 Renderización en tiempo real
 Soporte para programar aplicaciones para Android Wear
 Herramientas Lint para detectar problemas de rendimiento, usabilidad,
compatibilidad de versiones, y otros problemas.
 Refactorización especifica de Android y arreglos rápidos.
 Plantillas para crear diseños comunes de Android y otros componentes.

En entorno de desarrollo esta preparado para crear cualquier tipo de aplicación en

Android entre ellos podemos tener para televisor, teléfonos, reloj, google glass y/o
Google Claud. Como podemos apreciar en el siguiente grafico.
Figura 5: Soporte a aplicaciones por android studio
1.2.2 Creando la primera aplicación Hola Mundo.
Ingresar a Android studio y luego dar clic en el menú File/New Proyect
Application Name: Semana 01 Controles

Company Domain: SolucionesMoviles
Proyect Location: C:\AppsMoviles_5toCiclo
Dar click en Next

Seleccionar el API y el dispositivo donde se ejecutará de la aplicación:

Seleccionar la plantila para las pantallas inicialmente vamos a seleccionar un diseño en blanco.
Dar click en next
En la siguiente pantalla se debe considerar la siguiente información

Activity Name: Nombre de clase que se relaciona a la pantalla (layout)
Layout Name: Nombre de diseño de pantalla
Title: titúlo de la pantalla el que aparece cuando se ejecuta la aplicación
Menu Resource Name: el nombre de archivo xml de menú asociado al layout.
Dar click en finalizar para completar el asistente.

El proyecto que se crea
Donde
A: Archivos del proyecto
B: Diseño de pantalla en XML
C: Vistas de Text (XML) y Design (Diseño).
Visa de diseño de pantalla

En esta vista se puede apreciar el desarrollo de la aplicación en Android donde cada rectangolo
es una sección de apoyo de diseño de la aplicación.
Donde:
A: Cuadro de controles
B: Diseño de pantalla (Layout)
C: Vista esquema de controles
D: Vista propiedades de controles.

Hasta aquí nos quedamos con el ejercicio de crear la primera aplicación en Android
studio (Semana 01 Controles), a continuación vamos a revisar los principales controles
y sus propiedades para completar el desarrollo de nuestra primera aplicación.
1.2.3 Controles básicos Button, EditText, TextView
Los controles más básicos que tenemos en Android son sin duda Button, EditText y
textview los cuales nos permitirán crear una aplicación básica como por ejemplo un
login o un mantenimiento de datos en esta primera parte vamos a revisar en forma
preliminar los controles básicos que se muestra lo siguiente:
Figura 6: Controles Android

Fuente.- Tomado de http://developer.android.com/guide/topics/ui/controls.html
 TextView.- es un control etiqueta que permite mostrar textos de solo lectura en

la pantalla.
Para más detalles de los atributos y/o métodos puedes vistar la página oficial
de Android ingresando
http://developer.android.com/reference/android/widget/TextView.html
Definir el control por código XML
 EditText.- es un control que permite ingresar datos esta sujeto a aplicarle estilos
(Patrones) para mejorar el uso del mismo.
Para más detalles de los atributos y/o métodos puedes vistar la página oficial de
Android ingresando
http://developer.android.com/reference/android/widget/EditText.html

 Button.- Botones de acción permite involucrar eventos comunes como click con el fin
de que el usuario pueda realizar una tarea.
Para más detalles de los atributos y/o métodos puedes vistar la página oficial de
Android ingresando
http://developer.android.com/reference/android/widget/Button.html
Diseño de pantalla login

Para continuar con el ejercicio desarrollado anteriormente realizar los siguiente

Agregar los siguientes controles
1
1
2
2
2
Se debe agregar en el siguiente orden

1. Primero borrar todos los controles
existentes
2. Agregar el layout LinnerLayout
(Vertical)
3. Agregar 1 large text
4. Agregar un Plain TextView (Plain
TextView)
5. Agregar el control EditText (Plain
Text)
6. Hacer el mismo procedimiento para
los dos controles
7. Posterior a ellos agregar los controles
Botones de comando.
Para cambiar las propiedades dar doble

click en el control.
Donde Text es el texto a mostrarse y id es

ek nombre del control que se utilizara en
el código.
Finalmente el diseño de los controles quedará como se muestra:

En la vista texto (código XML) quedará como se muestra:
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:paddingLeft="@dimen/activity_horizontal_margin"
android:paddingRight="@dimen/activity_horizontal_margin"
android:paddingTop="@dimen/activity_vertical_margin"
android:paddingBottom="@dimen/activity_vertical_margin"
tools:context=".MainActivity">
<LinearLayout

android:orientation="vertical"
android:layout_width="fill_parent"
android:layout_height="fill_parent"
android:layout_alignParentTop="true"
android:layout_alignParentStart="true">
<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:textAppearance="?android:attr/textAppearanceLarge"
android:text="Control de acceso"
android:id="@+id/textView" />
<TextView
android:text="Usuario"
android:id="@+id/textView2" />
<EditText
android:ems="10"
android:id="@+id/edtusuario" />
<TextView
android:text="Contraseña"
android:id="@+id/textView3" />
<EditText
android:inputType="textPassword"
android:ems="10"

android:id="@+id/edtcontrasenia" />
<Button
android:text="Aceptar"
android:id="@+id/BtnAceptar" />
<Button
style="?android:attr/buttonStyleSmall"
android:text="Cancelar"
android:id="@+id/btnCancelar" />
</LinearLayout>
</RelativeLayout>
Finalmente al ejecutar la aplicación se muestra lo siguiente

1.4.5 Depuración de código en Android.
La depuración es una facilidad del IDE de Android studio con el objetivo de hacer
seguimeinto al código fuente y verificar algún error no esperado, limpiar el programa,
etc. Según Wikipedia la definición de deúración de programas es el proceso de
identificar y corregir errores de programación. En inglés se le conoce como debugging,
es que se asemeja a la eliminación de bichos (bugs), manera en que se conoce
informalmente a los errores de programación. Se dice que el término bugproviene de
la época de los ordenadores de válvula termoiónica, en los cuales los problemas se
generaban por los insectos que eran atraídos por las luces y estropeaban el equipo.
Ejecutar en modo depuración:
Agregar punto de interrupción para comenzar a ejecutar paso a paso

Menú con todas las opciones de depuración.

Resumen
1. El sistema operativo Android esta basado en el nucleo del sistema operativo
Android 2.6 y su creador es Andy Ruby.
2. Android es uno de los mejores sistemas operativos para dispositivos móviles por
excelencia.
3. Las características del dispositivo movil son basados en estándares abiertos.
4. La Open Handset Alliance es una estrategia comercial de apoyo mutuo para

mejorar la plataforma de estándares abiertos del sistema operativo movil android.
5. Android estudio es la herramientas más sofisticada para crear aplicaciones

basados en Android.
6. La depuración busca ubicar errors en el códido de nuestra aplicación y es una

facilidad del IDE con el fin de corregir errores de código o limpíar el programa.
Puede revisar los siguientes enlaces para ampliar los conceptos vistos en esta unidad:
o Recursos y documentación de la librería android:

https://developer.android.com/index.html
o Introducción a la plataforma Android:

http://www.ibm.com/developerworks/ssa/library/os-android-
devel/#resources

UNIDAD
2
ANDROID: COMPONENTES
Al término de la unidad, el alumno elabora aplicaciones que integran Activities,
componentes visuales, Intents y recursos externos pertenecientes a la
plataforma Android.
TEMARIO
2.1 Fundamentos de aplicaciones Android

2.1.1 Arquitectura de la plataforma Android.
2.1.2 Estructura de un proyecto Android. Archivos básicos, recursos, iconos
2.1.3 Ciclo de vida de un Activity
2.1.4 Componente Activity: definición y características.
2.1.5 Uso de recursos, acceso a String.XML.
2.1.6 Configuración del archivo de manifiesto
2.2 Componente de una pantalla: Views y ViewGroups

2.2.1 Componente de una pantalla: Views y ViewGroups
2.2.2 Distribución de los ViewGroups: LinearLayout, AbsoluteLayout, TableLayout,
Relative Layout, FrameLayout y ScrollView.
2.2.3 Controles ImageView, ImageButton, Spinner, Checkbox, ProgressBar
2.3 Componente Intent: definición y características

2.3.1 Uso de Intents para gestionar Actividades.
2.3.2 Resolviendo colisión de Intent Filter.
2.3.3 Invocación a otras aplicaciones usando Intents.
2.3.4 Uso del PendingIntent y notificaciones.
2.4 Orientación del dispositivo

2.4.1 Adaptación de la interface de usuario a la orientación del dispositivo
2.4.2 Manejar cambios en la orientación del dispositivo.
2.4.3 Diseño de interface de usuario con Views avanzados: ListView.
2.5 Dialogos y notificaciones

2.5.1 Dialog Window y Progress Dialog.
2.5.2 Dialogos personalizados basados en clases.
2.5.3 Toast, formatos, uso de estilos.
2.5.4 Menus, fuentes

ACTIVIDADES PROPUESTAS
 Los alumnos identifican el la arquitectura de las aplicaciones en android.

 Los alumnos identifican y usan los distintos diseños de pantalla.
 Los alumnos identifican los principales controles a utilizar para desarrollar
una aplicación básica.
 Los alumnos identifica y manejan el ciclo de vida de las activitys
 Los alumnos identifican y hacen uso de los controles básicos.
 Los alumnos programan los eventos de botones de comando en una
aplicación Android.

2.1. FUNDAMENTOS DE APLICACIONES ANDROID

Cuando creamos una aplicación para Android la estructura del proyecto es muy similar
a cualquier proyecto creado en la plataforma java, ya que el lenguaje es Java, para los
que conocen C#.Net, java, VB.net será muy sencillo familiarizarse con la plataforma
para ello primero vamos analizar la estructura de un proyecto en Android studio.
2.1.1. Plataforma Android

La plataforma Android es la más utilizada en la actualidad, por ello es muy
importante estar de acorde con los avances de la tecnología, el año que paso
se considero uno de los años en el que la plataforma Android se consagro en el
mercado como uno de los sistemas operativos mas revolucionarios del
mercado por ello en esta sección vamos a hacer un comparativo con los
competidores más cercanos como son iphone de Apple y Windows pone de
Microsoft. El siguiente grafico presenta
Figura 9: Lista de plataformas moviles en competencia según Garnert

Fuente.- Tomado de http://www.androidcurso.com/index.php/

Por otro lado es importante dentro de la comparación revisar la cuota de

mercado de cada una de las plataformas en el año 2014. Podemos destacar la
desaparición de la plataforma Symbian de Nokia, el declive continuo de
BlackBerry, el estancamiento de la plataforma de Windows, que parece que no
despega, y el afianzamiento de la cuota de mercado de Apple en torno al 20%.
Finalmente, cabe señalar el espectacular ascenso de la plataforma Android,
que en cinco años ha alcanzado una cuota de mercado en torno al 85%
Figura 10: cuota de mercado de las plataformas movile según Garnert

Fuente.- Tomado de http://www.androidcurso.com/index.php/
2.1.2. Estructura de un proyecto en android
Cuando creamos un proyecto en Android studio se presenta tal como se muestra en la

figura 11, en la parte izquierda, podemos observar todos los elementos creados
inicialmente para el nuevo proyecto Android,
sin embargo por defecto lo vemos agrupados
en .idea, app, gradle. Para entender mejor la
estructura del proyecto vamos a cambiar
momentáneamente la forma en la que Android
Studio nos la muestra. Para ello, pulsaremos
sobre la lista desplegable situada en la parte
Figura 11: Estructura de un proyecto en android

superior izquierda, y cambiaremos la vista de proyecto a “Project”.
Figura 12: Vista proyecto
Al cambiar la vista, los mismos archivos se presentan de otra manera como se observa en
la siguiente figura:
En los siguientes contenidos se describirá los

elementos principales de esta estructura.
Lo primero que debemos distinguir son los

conceptos de proyecto y módulo. La
entidad proyecto es única, y engloba a todos
los demás elementos. Dentro de un proyecto
podemos incluir varios módulos, que pueden
representar aplicaciones distintas, versiones
diferentes de una misma aplicación, o distintos
componentes de un sistema (aplicación móvil,
aplicación servidor, librerías). En la mayoría de los casos, trabajaremos con un proyecto
que contendrá un sólo módulo correspondiente a nuestra aplicación principal. Por ejemplo
en este caso que estamos creando tenemos el proyecto “AppsMoviles_5toCiclo” que
contiene al módulo “app” que contendrá todo el software de la aplicación de ejemplo.

Figura 14: Vista proyecto/Modulo
A continuación describiremos los contenidos principales de nuestro módulo principal.
Carpeta /app/src/main/java
Esta carpeta contendrá todo el código fuente de la aplicación, clases auxiliares, etc.
Inicialmente, Android Studio creará por nosotros el código básico de la pantalla
(actividad o activity) principal de la aplicación, que recordemos que en nuestro caso
era MainActivity, y siempre bajo la estructura del paquete java definido durante la creación
del proyecto.
Figura 15: Vista proyecto/Clases
Carpeta /app/src/main/res/
Contiene todos los ficheros de recursos necesarios para el proyecto: imágenes, layouts,
cadenas de texto, etc. Los diferentes tipos de recursos se pueden distribuir entre las
siguientes subcarpetas:
No todas estas carpetas tienen por qué aparecer en cada proyecto Android, tan sólo las
que se necesiten. Iremos viendo durante el curso qué tipo de elementos se pueden incluir
en cada una de ellas y cómo se utilizan.
Como ejemplo, para un proyecto nuevo Android como el que hemos creado, tendremos
por defecto los siguientes recursos para la aplicación:

Carpeta Descripción
Contiene las imágenes [y otros elementos gráficos] usados en por la
aplicación. Para poder definir diferentes recursos dependiendo de la
resolución y densidad de la pantalla del dispositivo se suele dividir en varias
subcarpetas:
 /drawable (recursos independientes de la densidad)
/res/drawable/  /drawable-ldpi (densidad baja)
 /drawable-mdpi (densidad media)
 /drawable-hdpi (densidad alta)
 /drawable-xhdpi (densidad muy alta)
 /drawable-xxhdpi (densidad muy muy alta :)
Contiene los ficheros de definición XML de las diferentes pantallas de la
interfaz gráfica. Para definir distintos layouts dependiendo de la orientación
/res/layout/ del dispositivo se puede dividir también en subcarpetas:
 /layout (vertical)
 /layout-land (horizontal)
/res/anim/
Contienen la definición de las animaciones utilizadas por la aplicación.
/res/animator/
/res/color/ Contiene ficheros XML de definición de colores según estado.
/res/menu/ Contiene la definición XML de los menús de la aplicación.
/res/xml/ Contiene otros ficheros XML de datos utilizados por la aplicación.
Contiene recursos adicionales, normalmente en formato distinto a XML,
/res/raw/
que no se incluyan en el resto de carpetas de recursos.
Contiene otros ficheros XML de recursos de la aplicación, como por
/res/values/ ejemplo cadenas de texto (strings.xml), estilos (styles.xml), colores
(colors.xml), arrays de valores (arrays.xml), tamaños (dimens.xml), etc.
Figura 16: Vista proyecto/Recursos
Como se puede observar, existen algunas carpetas en cuyo nombre se incluye un sufijo
adicional, como por ejemplo “values-w820dp”. Estos, y otros sufijos, se emplean para
definir recursos independientes para determinados dispositivos según sus características.
De esta forma, por ejemplo, los recursos incluidos en la carpeta “values-w820dp” se

aplicarían sólo a pantallas con más de 820dp de ancho, o los incluidos en una carpeta
llamada “values-v11” se aplicarían tan sólo a dispositivos cuya versión de Android sea la
3.0 (API 11) o superior. Al igual que los sufijos “-w” y “–v” existen otros muchos para
referirse a otras características del terminal, puede consultarse la lista completa en
la siguiente url:
http://developer.android.com/guide/topics/resources/providing-resources.html
Otro de los recursos creados por defecto cabe destacar los layouts, en nuestro caso sólo
tendremos por ahora el llamado “activity_main.xml”, que contienen la definición de la
interfaz gráfica de la pantalla principal de la aplicación. Si hacemos doble clic sobre este
fichero Android Studio nos mostrará esta interfaz en su editor gráfico, y como podremos
comprobar, en principio contiene tan los controles que agregamos en el primer ejercicio
Figura 17: Vista Previa de la aplicación
Pulsando sobre las pestañas inferiores “Design” y “Text” podremos alternar entre el editor
gráfico (tipo arrastrar-y-soltar), mostrado en la imagen anterior, y el editor XML que se
muestra en la imagen siguiente:

Figura 18: Vista código fuente
Durante el curso ustilizaremos ambos casos, el más efectivo es vía código XML, ya que a
veces el diseñador puede tener complicaciones o demorar dependiendo de la complejidad
de del diseño de pantalla.
Fichero /app/src/main/AndroidManifest.xml
Contiene la definición en XML de muchos de los aspectos principales de la aplicación,

como por ejemplo su identificación (nombre, icono, …), sus componentes (pantallas,
servicios, …), o los permisos necesarios para su ejecución. Veremos más adelante más
detalles de este fichero. En el caso de nuestra aplicación creada se tiene el siguiente
código en el archivo manifiesto
Figura 19: Vista código XML archivo manifiesto

Fichero /app/build.gradle
Contiene información necesaria para la compilación del proyecto, por ejemplo la versión
del SDK de Android utilizada para compilar, la mínima versión de Android que soportará la
aplicación, referencias a las librerías externas utilizadas, etc. Más adelante veremos
también más detalles de este fichero.
En un proyecto pueden existir varios ficheros build.gradle, para definir determinados

parámetros a distintos niveles. Por ejemplo, en nuestro proyecto podemos ver que existe
un fichero build.gradle a nivel de proyecto, y otro a nivel de módulo dentro de la carpeta
/app. El primero de ellos definirá parámetros globales a todos los módulos del proyecto, y
el segundo sólo tendrá efecto para el módulo correspondiente.
Carpeta /app/libs
Puede contener las librerías javas externas (ficheros .jar) que utilice nuestra aplicación.
Normalmente haremos referencia a dichas librería en el fichero build.gradle descrito en el
punto anterior, de forma que entren en el proceso de compilación de nuestra aplicación.
Veremos algún ejemplo más adelante.
Carpeta /app/build/
Contiene una serie de elementos de código generados automáticamente al compilar el
proyecto. Cada vez que compilamos nuestro proyecto, la maquinaria de compilación de
Android genera por nosotros una serie de ficheros fuente java dirigidos, entre otras
muchas cosas, al control de los recursos de la aplicación.Importante: dado que estos
ficheros se generan automáticamente tras cada compilación del proyecto es importante
que no se modifiquen manualmente bajo ninguna circunstancia.
Figura 20: Vista depuración
A destacar sobre todo el fichero que aparece desplegado en la imagen anterior, llamado
“R.java”, donde se define la clase R. Esta clase R contendrá en todo momento una serie
de constantes con los identificadores (ID) de todos los recursos de la aplicación incluidos
en la carpeta /app/src/main/res/, de forma que podamos acceder fácilmente a estos
recursos desde nuestro código a través de dicho dato. Así, por ejemplo, la

constante R.layout.activity_main contendrá el ID del layout “activity_main.xml” contenido

en la carpeta /app/src/main/res/layout/.
Vista Android
El siguiente grafico presenta un proyecto creado en Android studio en la vista
Android
Figura 21: Vista Android

Donde
A: Archivo de manifiesto archivo xml de configuración de aplicaciones.
B: Activity, Clase que se asocia con el diseño

de pantalla (layout)
C: Clase de prueba que permite hacer

pruebas unitarias.
D: Imágenes (iconos) de diferentes tamaños

que se utilizará para cuando la aplicación se
ejecute en un celular, Tablet, televisor etc se
cambia de imagen segpun el tamaño de la
pantalla.
E: layout, Pantalla (s) que se tiene en el

proyecto, todos los diseños de pantalla están
basado en XML.
F: Archivo xml con el cual se configura el

menú para el diseño de pantalla principal.
G: Archivo de recursos que almacena cadenas

de arreglo, como puede ser el caso de países,
estado civil, sexo, ect.
String.XMl almacena las variables o valores de
las propiedades de los controles que se
utilizan para diseñar la aplicación.
H: Archivos de estilos, permite diseñar estilos

que pueden ser utilizados de manera muy
similar a una hoja de estilos en una página web. Figura 22: Vista Archivos de proyecto

¿Que es un Gradle?
Con el lanzamiento de Android Studio, también apareció un nuevo concepto llamado

Gradle que da Excelentes mejoras para hacer que el desarrollo de una aplicación en
Android sea más rápido. Gradle es un sistema de construcción avanzado, así como un
set de herramientas de construcción avanzada que permite la creación de una lógica
de construcción personalizada a través de plugins.
Estas son algunas de sus características que hicieron elegir Gradle al equipo de
Android:
 Buena estampación de la API permitiendo integración con el IDE.

 Lenguaje específico del Dominio (DSL) para describir y manipular la lógica
de construcción
 Muy flexible. Permite utilizar mejores prácticas pero no fuerza su propia
manera de hacer las cosas.
 Incorpora gestor de dependencias a través de Maven y/o Ivy.
 Los Plugins pueden exponer su propio DSL y su propia API para crear
archivos para su uso.
 Construye archivos basados en Groovy y permite la mezcla de elementos
declarativos a través de la DSL y la utilización de código para manipular los
elementos de la DSL para proporcionar lógica personalizada.

2.6 Componente de una pantalla: Views y ViewGroups
Componente de una pantalla: Views y ViewGroups

La interfaz de usuario se define en un archivo XML que se almacena en la carpeta
res/layout, cada una de las pantallas, se crea por código XML y estándares XML.
También es posible diseñar una pantalla usando código Java, sin embargo puede
resultar complejo y poco eficiente, por ello el IDE Android studio facilita el diseño de
pantallas, cada uno representando a un "subclase" específica de view. Se pueden
crear pantallas de la misma manera que se diseñan páginas HTML.
Cada archivo describe un layout (una pantalla) y cada layout a su vez puede contener
otros elementos (vistas o controles). Para gestionar la interfaz de usuario, Android
introduce las siguientes terminos:
View
Una view es un objeto cuya clase es android.view.View. Es una estructura de datos
cuyas propiedades contienen los datos de la capa, la información específica del área
rectangular de la pantalla y permite establecer el layout. Una view tiene: layout,
drawing, focus change, scrolling, etc.
La clase view es útil como clase base para los widgets, que son unas subclases ya
implementadas que dibujan los elementos en la pantalla. Los widgets contienen sus
propias medidas, pero puedes usarlas para construir tu interfaz más rápidamente. La
lista de widgets que puedes utilizar incluye Text, EditText, InputMethod,
MovementMethod, Button, RadioButton, CheckBox, y ScrollView.
Viewgroups
Un viewgroup es un objeto de la clase android.view.Viewgroup, como su propio
nombre indica, un viewgroup es un objeto especial de view cuya function es contener y
controlar la lista de views y de otros viewgroups. Los viewgroups te permiten añadir
estructuras a la interfaz y acumular complejos elementos en la pantalla que son
diseccionados por una sola entidad.
La clase viewgroup es útil como base de la clase layouts, que son subclases
implementadas que proveen los tipos más comunes de los layouts de pantalla. Los
layouts proporcionan una manera de construir una estructura para una lista de views.

Árbol estructurado de la interfaz UI

En la plataforma Android tú defines una Activity del UI usando un árbol de nodos view
y viewgroups, como vemos en la imágen de abajo. El árbol puede ser tan simple o
complejo como necesites hacerlo, y se puede desarrollar usando los widgets y layouts
que Android proporciona o creando tus propios views.
Figura 23: Jerarquí visual de android

Fuente: http://www.gitsinformatica.com/android.html
Los views y viewgroups deben estar contenidos en los layouts, los cuales contienen
otros elementos presentes en una vista. Dentro de cada layout podemos poner todos
los elementos necesarios, incluidos otros layouts. Así conseguiremos estructurar la
pantalla de la manera deseada. Existen una gran variedad de layouts, en función de su
posicionamiento en la pantalla y se describen a continuación algunos de ellos:
Distribución de los ViewGroups

Los layouts son elementos no visuales destinados a controlar la distribución, posición y
dimensiones de los controles que se insertan en su interior. Estos componentes
extienden a la clase base ViewGroup, como muchos otros componentes
contenedores, es decir, capaces de contener a otros controles. En el post anterior
conocimos la existencia de un tipo concreto de layout, LinearLayout, aunque Android
nos proporciona algunos otros.

FrameLayout
Éste es el más simple de todos los layouts de Android. Un FrameLayout coloca todos
sus controles hijos alineados con su esquina superior izquierda, de forma que cada
control quedará oculto por el control siguiente (a menos que éste último tenga
transparencia). Por ello, suele utilizarse para mostrar un único control en su interior, a
modo de contenedor (placeholder) sencillo para un sólo elemento sustituible, por
ejemplo una imagen.
Los componentes incluidos en un FrameLayout podrán establecer sus propiedades

android:layout_width y android:layout_height, que podrán tomar los valores “fill_parent”
(para que el control hijo tome la dimensión de su layout contenedor) o “wrap_content”
(para que el control hijo tome la dimensión de su contenido).
Ejemplo:
<FrameLayout
xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_height="fill_parent">
<EditText android:id="@+id/TxtNombre"
android:layout_height="fill_parent" />
</FrameLayout>
LinearLayout
El siguiente layout Android en cuanto a nivel de complejidad es el LinearLayout. Este
layout apila uno tras otro todos sus elementos hijos de forma horizontal o vertical
según se establezca su propiedad android:orientation. Al igual que en un
FrameLayout, los elementos contenidos en un LinearLayout pueden establecer sus
propiedades android:layout_width y android:layout_height para determinar sus
dimensiones dentro del layout. Pero en el caso de un LinearLayout, tendremos otro
parámetro con el que jugar, la propiedad android:layout_weight.
<LinearLayout
android:orientation="vertical">
<Button android:id="@+id/BtnAceptar"
</LinearLayout>

Esta propiedad nos va a permitir dar a los elementos contenidos en el layout unas
dimensiones proporcionales entre ellas. Esto es más dificil de explicar que de
comprender con un ejemplo. Si incluimos en un LinearLayout vertical dos cuadros de
texto (EditText) y a uno de ellos le establecemos un layout_weight=”1″ y al otro un
layout_weight=”2″ conseguiremos como efecto que toda la superficie del layout quede
ocupada por los dos cuadros de texto y que además el segundo sea el doble (relación
entre sus propiedades weight) de alto que el primero.
<LinearLayout
android:orientation="vertical">
<EditText android:id="@+id/TxtDato1"
android:layout_weight="1" />
<EditText android:id="@+id/TxtDato2"
android:layout_weight="2" />
</LinearLayout>
A pesar de la simplicidad aparente de este layout resulta ser lo suficiente versátil como
para sernos de utilidad en muchas ocasiones.
TableLayout
Un TableLayout permite distribuir sus elementos hijos de forma tabular, definiendo las
filas y columnas necesarias, y la posición de cada componente dentro de la tabla.
La estructura de la tabla se define de forma similar a como se hace en HTML, es decir,
indicando las filas que compondrán la tabla (objetos TableRow), y dentro de cada fila
las columnas necesarias, con la salvedad de que no existe ningún objeto especial para
definir una columna (algo así como un TableColumn) sino que directamente
insertaremos los controles necesarios dentro del TableRow y cada componente
insertado (que puede ser un control sencillo o incluso otro ViewGroup) corresponderá
a una columna de la tabla. De esta forma, el número final de filas de la tabla se
corresponderá con el número de elementos TableRowinsertados, y el número total de
columnas quedará determinado por el número de componentes de la fila que más
componentes contenga.
Por norma general, el ancho de cada columna se corresponderá con el ancho del
mayor componente de dicha columna, pero existen una serie de propiedades que nos
ayudarán a modificar este comportamiento:

 android:stretchColumns. Indicará las columnas que pueden expandir para

absorver el espacio libre dejado por las demás columnas a la derecha de la
pantalla.
 android:shrinkColumns. Indicará las columnas que se pueden contraer para
dejar espacio al resto de columnas que se puedan salir por la derecha de la
palntalla.
 android:collapseColumns. Indicará las columnas de la tabla que se quieren
ocultar completamente.
Todas estas propiedades del TableLayout pueden recibir una lista de índices de
columnas separados por comas (ejemplo: android:stretchColumns=”1,2,3″) o un
asterisco para indicar que debe aplicar a todas las columnas (ejemplo:
android:stretchColumns=”*”).
Otra característica importante es la posibilidad de que una celda determinada pueda

ocupar el espacio de varias columnas de la tabla (análogo al atributo colspan de
HTML). Esto se indicará mediante la propiedad android:layout_span del componente
concreto que deberá tomar dicho espacio.
Veamos un ejemplo con varios de estos elementos:
<TableLayout
android:stretchColumns="1" >
<TableRow>
<TextView android:text="Celda 1.1" />
</TableRow>
<TableRow>
</TableRow>
<TableRow>
<TextView android:text="Celda 3"
android:layout_span="2" />
</TableRow>
</TableLayout>
RelativeLayout
El último tipo de layout que vamos a ver es el RelativeLayout. Este layout permite
especificar la posición de cada elemento de forma relativa a su elemento padre o a
cualquier otro elemento incluido en el propio layout. De esta forma, al incluir un nuevo

elemento X podremos indicar por ejemplo que debe colocarse debajo del elemento Y y
alineado a la derecha del layout padre. Veamos esto en el ejemplo siguiente:
<RelativeLayout
xmlns:android="http://schemas.android.com/apk/res/android
android:layout_height="fill_parent" >
android:layout_height="wrap_content" />
<Button android:id="@+id/BtnAceptar"
android:layout_below="@id/TxtNombre"
android:layout_alignParentRight="true" />
</RelativeLayout>
En el ejemplo, el botón BtnAceptar se colocará debajo del cuadro de texto TxtNombre

(android:layout_below=”@id/TxtNombre”) y alineado a la derecha del layout padre
(android:layout_alignParentRight=”true”), además de dejar un margen a su izquierda
de 10 pixeles (android:layout_marginLeft=”10px”).
Al igual que estas tres propiedades, en un RelativeLayout tendremos un sinfín de
propiedades para colocar cada control justo donde queramos. Veamos las principales
[creo que sus propios nombres explican perfectamente la función de cada una]:
Posición relativa a otro control:
 android:layout_above.
 android:layout_below.
 android:layout_toLeftOf.
 android:layout_toRightOf.
 android:layout_alignLeft.
 android:layout_alignRight.
 android:layout_alignTop.
 android:layout_alignBottom.
 android:layout_alignBaseline.
 Posición relativa al layout padre:
 android:layout_alignParentLeft.
 android:layout_alignParentRight.
 android:layout_alignParentTop.
 android:layout_alignParentBottom.
 android:layout_centerHorizontal.
 android:layout_centerVertical.
 android:layout_centerInParent.

 Opciones de margen (también disponibles para el resto de layouts):

 android:layout_margin.
 android:layout_marginBottom.
 android:layout_marginTop.
 android:layout_marginLeft.
 android:layout_marginRight.
 Opciones de espaciado o padding (también disponibles para el resto de
layouts):
 android:padding.
 android:paddingBottom.
 android:paddingTop.
 android:paddingLeft.
 android:paddingRight.
Otros elementos comunes que extienden a ViewGroup, como por ejemplo las vistas de
tipo lista (ListView), de tipo grid (GridView), y en pestañas (TabHost/TabWidget).

Widgets
Un widget es el conjunto de componentes visuales que permite crear las aplicaciones
en Android. Entre dichos compoenentes tenemos Button, TextView, EditText. El
package donde se importa todos los controles es android.widget.
Figura 24: compoentes widget en los celulares

Fuente: http://bitelia.com/2014/01/widgets-android
Botones (Button)
El SDK de Android nos proporciona tres tipos de botones: el Clásico (Button), el de

tipo on/off (ToggleButton), y el que puede contener una imagen (ImageButton). En la
imagen siguiente vemos el aspecto por defecto de estos tres controles.
Figura 25: Vista cuadro de herramientas Widgets

Propiedades
android:id
Esto ya lo vimos en el tema anterior, esta propiedad es el ID del control, con el
que podremos identificarlo de forma única más tarde en nuestro código. Vemos
que el identificador lo escribimos precedido de “@+id/”. Esto tendrá como
efecto que al compilarse el proyecto se genere automáticamente una nueva
constante en la clase R para dicho control.
android:text.
Texto del control. En Android, el texto de un control se puede especificar
directamente, o bien utilizar alguna de las cadenas de texto definidas en los
recursos del proyecto (fichero strings.xml), en cuyo caso indicaremos su
identificador precedido del prefijo “@string/”.
android:layout_height y android:layout_width
Dimensiones del control con respecto al layout que lo contiene. Esta propiedad
tomará normalmente los valores “wrap_content” para indicar que las
dimensiones del control se ajustarán al contenido del mismo, o bien “fill_parent”
para indicar que el ancho o el alto del control se ajustarán al ancho o alto del
layout contenedor respectivamente.
Unidades de medida para esta propiedad

px. Píxeles, corresponde a píxeles reales en la pantalla.
en.
Cm - basado en el tamaño físico de la pantalla.
mm. Milímetros - en función del tamaño físico de la pantalla.
pt. Puntos - 1/72 de una pulgada en función del tamaño físico de la pantalla.
sp. Escala de píxeles independientes - esto es como la unidad de DP, pero
también es escalado por la preferencia del usuario tamaño de la fuente. Se
recomienda utilizar esta unidad al especificar tamaños de fuente, por lo que se
ajusta tanto para la densidad de pantalla y preferencias del usuario.
android:layout_margin

Este parametro indica el espacio entre el control (en este caso botón) y su
padre en este caso el Layout.
android:padding
Este parámetro indica el espacio entre Texto o Imágenes que pongamos dentro
del control (en este caso el botón) y el propio control.
android:gravity
Esta es la gravedad del control, la verdad es que es una forma original de
poner la alineación, si entre las comillas de este parámetro pulsamos la famosa
combinación de teclas Control+Espacio, eclipse nos dará todos los parámetros
que podemos usar aquí, si ponemos solo "center" se centrara su contenido
tanto vertical como horizontal.
android:drawable
Con este parámetro pondremos una imagen al botón, que no es lo mismo que
el ImageButton, que todo el botón es en si una imagen, con esto ponemos una
especie de icono dentro del botón, por ejemplo si queremos poner el tipoco
Play, Stop las flechas de avance o retroceso... existen variantes de este
parámetro para poner la imagen a la derecha o izquierda, arriba o abajo.
android:Text
Con este parametro definimos el texto del botón, podemos usar un recurso R
usando "@String/texto o directamente un texto entre comillas.
android:TextSize
Indicamos un tamaño, si no ponemos esto, se selecciona un tamaño por
defecto standard, si te parece grando o pequeño ve probando usando la unidad
dp que vimos en el tema anterior.
android:backgroud
Con este parámetro definimos el color de fondo del Boton.
android:OnClick

Esta es una propiedad que nos ayuda con el Listener, al final de la lección
hablo de esto, que es la parte Java del Boton, esto nos facilita la vida, lo malo
es que solo se puede utilizar a partir de la API 6 de Android, no creo que vallas
a hacer un proyecto con esta API yo uso esta opción, es menos lioso.
Ejemplo de definición de botón de comando
Ejemplo de botón con estilo
Evento del botón de comando
EditText
EditText (caja de edición de texto) es un cuadro de texto para ingresar datos en
Android este controlt tiene patrones definidos para permitir el ingreso de información
correcta según el tipo de ingreso definido.

android:hint. Con este parámetro pondremos un texto por defecto mientras el campo
este vacío, es decir, el lo que ve el usuario antes de que el escriba nada.
android:inputType. Con este parámetro indicamos el tipo de teclado que quieres que
aparezca cuando pulsas sobre el campo, si por ejemplo solo vamos a introducir
números, se puede indicar que aparezca un teclado numérico. Como siempre cuando
te coloques entre las comillas pulsa Control+Espacio para ver las opciones que
puedes poner para este parámetro.
Control Usuario EditText
Ejemplo de acceso a las propiedade por código

Componente Activity e Intent: definición y características
Actitivity (Actividad)
Un Activity (actividad) es una clase que permite manejar los eventos de cualquier
aplicación desarrollada en Android, esta diseñada para controlar toda la funcionalidad
de cualquier aplicación, Podemos decir que todas las pantallas de una aplicación son
una “activity”. Más adelante vamos a ver que existen algunas variaciones, por ejemplo,
que si una aplicación tiene cinco pantallas, tiene 5 “Actividades” o activities.
Las activities están conformadas por dos partes: la parte lógica y la parte gráfica. La
parte lógica es una archivo .java que es la clase que se crea para poder manipular,
interactuar y colocar el código de esa actividad. Toda actividad debe tener asociado
una pantalla La parte gráfica es un XML que tiene todos los elementos que estamos
viendo de una pantalla declarados con etiquetas parecidas a las del HTML, es decir,
que el diseño de una aplicación en Android se hace similar a una página web; XML es
un primo de HTML.
Resumiendo, una actividad está conformada por la parte lógica (un archivo Java) y la
parte gráfica (un archivo XML). Profundizando más en el tema, ya sabemos que
tenemos un archivo .java, esto quiere decir que tenemos una clase principal, al ser una
actividad extiende de la clase Activity (por eso el nombre) que nos proporciona Android
para crear actividades con sus métodos asignados.
Un ejemplo de nuestro activity "MaActivity.java" podemos apreciar el código:

Primero veremos que existen dos secciones de código:

El primero es el paquete de nuestra aplicación
Y posterior a ello las importaciones
La actividad de se extiende desde la clase base Activity
El método onCreate es el método que se ejecuta primero al iniciar cualquier activity en

este caso este método es similar el método main y se enlaza con el layout (diseño de
pantalla) mediante el Código setContenView( R.layout.activity_Main);
Para ellazar controle se debe agregar código después de esta línea.
Que es la que hace el trabajo de enlazar la parte lógica con la parte gráfica. El archivo
XML que va a mostrarse cuando se mande a llamar la clase "MainActivity" es el
archivo XML llamado "activity_main".
Para cerrar la explicación: si yo creo una actividad nueva y la llamo
"VentanaPrinicipal", debo hacer que herede de activity si quiero que funcione como
actividad y para decirle que el archivo XML que va a mostrar sea el
"ventanaprincipal.xml" o "pepito.xml". La línea que dice "SetContentView" debe llevar
dentro algo parecido a esto: "setContentView"(R.layout.ventanaprincipal).

Más adelante vamos a ver como agregar una actividad nueva, ya que además de esto
necesitamos hacer otras cosas en el proyecto. Espero por ahora que quede claro el
término de Activity que vamos a estar utilizando.
Ciclo de vida de la clase Activity

La base de una aplicación en Android Android son las Activity-s, en el sistema se
ejecutan como "tareas activity". Cuando es iniciada una nueva Activity se pone al inicio
de la pila de ejecución y se convierte en la Activity en ejecución. La Activity que
estuviera ejecutándose antes siempre estará por debajo en la pila y no volverá a
primer plano mientras la nueva Activity exista.
En el siguiente diagrama vemos claramente cual es el ciclo de vida de este tipo de

clases.
Figura 26: ciclo de vida del activity

Fuente.- Tomado de http://www.android-app-market.com/

Es muy importante tener en cuenta este diagrama ya que cuando estamos desarrollando una
aplicación Android, todas las aplicaciones cumplen con este ciclo de vida y dependiendo de la
aplicación debemos manejar estos ciclos de vida para gestión nuestra aplicación y los recursos
que maneja. Por ejemplo cuando una aplicación cambia de orientación de vertical a horizontal
se inicia con el método onResume. A continuación de describe cada uno de los eventos del
ciclo de vida de un activity
Evento Descripción y/o funcionalidad Abortable Siguiente

Se ejecuta cuando se crea la Activity por
primera vez. Aquí es donde se deberían crear
onCreate() No onStart()
views, enlazar datos a listas,… en definitiva el
proceso de inicialización de nuestra aplicación.
Se ejecuta después de que la aplicación se haya
onRestart() detenido, justo después de que sea iniciada de No onStart()
nuevo.
Se ejecuta justo antes de que la aplicación

aparezca visible para el usuario. Si la aplicación
onResume()
es un proceso en background el siguiente
onStart() No o
estado es onStop(), si la aplicación se ejecuta
onStop()
en foreground el siguiente método es
onResume().
Se ejecuta cuando la Activity interactúa con el

onResume( usuario. En éste punto la Activity está en la cima No onPause()
de la pila.
Se ejecuta cuando el sistema está a punto de
continuar una Activity anterior. Se utiliza
típicamente para guardar datos que no se han onResume()
onPause() grabado anteriormente, parar animaciones y Si o
otras acciones que consuman CPU. Seguida por onStop()
onResume() si la actividad vuelve a primer plano
o onStop() si es invisible para el usuario.
Se ejecuta cuando la Activity deja de ser visible

al usuario, porque otra Activity ha continuado y
pasa a un lugar más prioritario de la pila. Puede
ocurrir porque una nueva Activity ha sido onRestart()
onStop() creada, una Activity ya creada pasa a primer Si o
plano o ésta está siendo destruida. El siguiente onDestroy()
método será onRestart() si la Activity vuelve a
interaccionar con el usuario o por onDestroy() si
la Activity será destruida.
Última llamada antes de destruir la Activity.

Puede ocurrir porque la actividad está acabando
(llamada a finish() ) , o porque el sistema
onDestroy() Si NADA
destruirá la instancia para guardar espacio. Se
puede distinguir esos escenarios con el método
isFinishing().

Introducción a los Intents
Android usa los intent como mecanismo para invocar componentes, los intents son
bastante fáciles de comprender. Básicamente nos permiten llamar a aplicaciones
externas a la nuestra, lanzar eventos a los que otras aplicaciones puedan responder,
lanzar alarmas etc.
Ejemplo: Tenemos el siguiente activity creado

public class MiActivity extends Activity {
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.MiActivity);
}
}
El layout R.Layout.MainActivity debe estar declarado y ser un archivo de layout valido.

Una vez creado este archivo de layout, es necesario registrarlo en el AndroidManifest,
que será algo así tal como lo vemos en la primera aplicación que desarrollamos:
El registro de la activity se realiza de forma automática, tal como también se registra

una acción que podremos usar para invocar a dicha actividad. El diseñador de la
actividad puede asignar el nombre que crea conveniente a la acción. Ahora que ya
está todo listo, podemos lanzar un intent para llamar a esta actividad:
public static void LlamarActivity(Activity activity){

String actionName= "android.intent.action.MAIN";

Intent intent = new Intent(actionName);
activity.startActivity(intent);
}
La convención que se usa para nombrar una acción suele

ser android.intent.action.MAIN
Una vez que se invoca a la actividad, ésta tiene la posibilidad de recuperar el intent
que la llamó. Y podemos recuperarlo del siguiente modo:
//Este código se inserta en el método onCreate() de la actividad.

Intent intent = this.getIntent();
if (intent == null){
Log.d("Tag", "La actividad no se ha llamado mediante un intent.")
}
Para más detalles puedes ingresar al siguiente link: developer.android.com/guide/appendix/g-app-

intents.html
Funcionalidad y uso de Intents

Se puede encontrar una lista con las aplicaciones disponibles en Android junto con los
intents que las invocan. Por ejemplo, para el navegador web, tenemos dos
acciones, VIEW y WEB_SEARCH, que abren el navegador en una url específica o
realizan una búsqueda.
En el caso del dialer (marcador), tenemos las acciones CALL y DIAL, que vienen
dadas por la URI tel: numero_de_teléfono, la diferencia entre estas dos acciones, es
que CALL realiza la llamada al número de la URI, y DIAL solo lo marca, pero no realiza
la llamada.
Ejemplos de uso de Intent

Ejemplo para abrir en nevegador predeterminado en el celular.
public static void AbrirNavegador (Activity activity){
Intent intent = new Intent(Intent.ACTION_VIEW );
intent.setData(Uri.parse("http://www.google.com"));
}
Abrir el buscador predeterminado en el celular.

public static void AbrirBuscador(Activity activity){
Intent intent = new Intent(Intent.ACTION_WEB_SEARCH);
intent.setData(Uri.parse("http://www.google.com"));

}
public static void AbrirVentanaLlamada(Activity activity){
Intent intent = new Intent(Intent.ACTION_DIAL);
}
public static RealizarLlamada call(Activity activity){

Intent intent = new Intent(Intent.ACTION_CALL);
intent.setData(Uri.parse("tel:555-555-555"));
}
public static void LlamargoogleMaps(Activity activity){

Intent intent = new Intent(Intent.ACTION_VIEW );
intent.setData(Uri.parse("geo:0,0?z=4&q=restaurantes"));
}
Pasar datos entre activitys mediante Intent
Para ello se debe realizar de la siguiente manera:
Gestión de problemas de pantallas
El objetivo de soportar múltiples pantallas es crear una aplicación que pueda funcionar
correctamente y se vea bien en cualquiera de las configuraciones de pantalla generalizadas
compatibles con Android. En las secciones anteriores de este documento proporcionan
información acerca de cómo Android se adapta a su aplicación a las configuraciones de
pantalla y cómo se puede personalizar el aspecto de su aplicación en diferentes

configuraciones de pantalla. Esta sección proporciona algunos consejos adicionales y una

visión general de las técnicas que ayudan a asegurarse de que su aplicación se escala
correctamente para configuraciones de pantalla diferentes.
Aquí está una lista rápida de cómo se puede asegurar que la aplicación muestra correctamente
en pantallas diferentes:
1. Utilice wrap_content , fill_parent o unidades dp al especificar dimensiones en un archivo de
formato XML
2. No utilice los valores de píxeles en el código
3. No utilice AbsoluteLayout (está en desuso)
4. Suministre drawables alternativos para densidades de pantalla diferentes
En las secciones siguientes se proporcionan más detalles.
1. Use wrap_content, fill_parent, o la unidad de DP para dimensiones del diseño

Al definir el android:layout_width y Android:layout_height para vistas en un archivo de formato
XML, utilizando "wrap_content" , "fill_parent" o unidades dp se garantiza que a la vista se le da
un tamaño apropiado en la pantalla del dispositivo actual.
Por ejemplo, una vista con un layout_width = "100dp" mide 100 pixeles de ancho en la pantalla
de densidad media y hasta 150 píxeles de ancho en la pantalla de alta densidad, de modo que
la vista ocupa aproximadamente el mismo espacio físico en la pantalla .
Del mismo modo, se debe preferir el sp (escala independiente de píxeles) para definir tamaños
de texto.
2. No utilice valores codificados de píxeles en el código de aplicación

Por cuestiones de rendimiento y mantener el código más simple, el sistema Android utiliza
píxeles como unidad estándar para expresar los valores de cota o coordenada. Eso significa
que las dimensiones de una vista se expresan siempre en el código mediante píxeles, pero
siempre se basa en la densidad de pantalla actual. Por ejemplo, si myView.getWidth() devuelve
10, la vista es 10 píxeles de ancho en la pantalla actual, pero en un dispositivo con una pantalla
de mayor densidad, el valor devuelto puede ser 15. Si utiliza valores de los píxeles en el código
de aplicación para trabajar con mapas de bits que no están pre-escalados para la densidad de
pantalla actual, puede que tenga que escalar los valores de los píxeles que se utilizan en el
código para que coincida con la fuente de mapa de bits sin escala.
Si su aplicación manipula mapas de bits o se ocupa de los valores de píxel en tiempo de
ejecución, consulte la siguiente sección sobre Consideraciones adicionales de densidad.
3. No utilice AbsoluteLayout
A diferencia de los widgets de otros diseños, AbsoluteLayout refuerza el uso de posiciones fijas
para exponer sus vistas, lo que pueden llevar fácilmente a que las interfaces de usuario no
funcionen bien en pantallas diferentes. Debido a esto, AbsoluteLayout está desfasada y en
Android 1.5 (Nivel API 3).

En su lugar, debe utilizar RelativeLayout , que utiliza posicionamiento relativo. Por ejemplo,
puede especificar que un widget de botón debe aparecer "a la derecha de" un widget de texto.
4. Use el tamaño y densidad de recursos específicos

Aunque el sistema de escalas de su diseño y recursos drawables basado en la configuración
actual de la pantalla, es posible que desee realizar ajustes en la interfaz de usuario en
diferentes tamaños de pantalla y proporcionar drawables que están optimizados para diferentes
densidades. Esto, en esencia reitera la información de arriba en este documento.
Si necesita controlar exactamente cómo su aplicación se verá en varias configuraciones de
pantalla, ajustar los diseños y drawables en directorios de recursos de configuración
específicos. Por ejemplo, considere un icono que desea mostrar en las pantallas de media y
alta densidad. Sólo tienes que crear tu icono en dos tamaños diferentes (por ejemplo 100x100
de densidad media y 150x150 de alta densidad) y poner las dos variaciones en los directorios
adecuados, utilizando los calificadores apropiados:
res/drawable-mdpi/icon.png //for medium-density screens
res/drawable-hdpi/icon.png //for high-density screens
Nota: Si un calificador de densidad no está definido en un nombre de directorio, el sistema

asume que los recursos en ese directorio están diseñados para la línea de base de densidad
media y se escala para otras densidades, según proceda.
Cómo probar la aplicación en varias pantallas

Figura 17. Un conjunto de AVDS para probar pantallas de apoyo.
Antes de publicar su aplicación, usted debe probarlo a fondo en todos los tamaños de
pantalla admitidos y densidades. El SDK de Android incluye un emulador que puede
utilizar, que replican los tamaños y densidades de configuraciones de pantalla
comunes en los que su aplicación es probable que se ejecute. También se puede
modificar el tamaño predeterminado, la densidad y resolución del emulador para
reproducir las características de cualquier pantalla específica. El uso del emulador y
las configuraciones personalizadas adicionales le permite probar cualquier
configuración de pantalla posible, por lo que no tiene que comprar varios dispositivos
sólo para poner a prueba el soporte de su solicitud de pantalla.
Para configurar un entorno de prueba debe crear una serie de AVDS (Android Virtual
Devices), utilizando el emulador y configuraciones de pantalla que emulan los tamaños
de pantalla y densidades que desean. Para ello, puede utilizar el Administrador de
AVD para crear las AVDS y lanzarlos con una interfaz gráfica.

Orientación del dispositivo
La funcionalidad de todo teléfono con sistema operativo Android es que tiene la

capacidad de adaptarse tanto a la pantalla como a la orientación que tiene el
dispositivo, vertical o horizontal, sin embargo en algunas ocaciones es necesario
mantener la orientación como el caso de los juegos es necesario mantener la
horientacipon en horizontal para aprovechar la capacidad de la pantalla.
Figura 27: configuración de orientación

Fuente: tomado desde http://es.wikihow.com/cambiar-la-orientaci%C3%B3n-de-la-pantalla-en-Android

La orientación, se puede configurar dentro por medio de código XML como se aprecia
en la siguiente imagen
Existe la posibilidad de evitar este comportamiento por defecto de Android frente a los
cambios dinámicos de configuración, simplemente añadiendo en el Manifest a la
activity la opción
android:configChanges="orientation|keyboardHidden"
Importante! Para que esta técnica funcione si usamos para nuestra app un target
superior a Gingerbread (API 10) , solo funciona en las versiones superiores :
android:configChanges="orientation|keyboardHidden|screenSize"
Con esto estamos indicando que el cambio de configuración lo gestionará

directamente la app, por lo que la Activity no se reinicia y se invoca el
método onConfigurationChanged(Configuration newConfig) que deberemos
sobreeescribir para realizar todos los cambios que queramos al cambiarse la
orientación del dispositivo.Obsérvese que siguiendo esta estrategia NO se cambia

automáticamente el layout en el caso de que se hayan definido layout distintos, por lo

que si fuera necesario no quedaría más remedio que hacer estos cambios
programáticamente.
Por medio de código se puede realizar lo siguiente:
Para más deralle ingresar al siguiente link:

http://developer.android.com/guide/topics/resources/runtime-changes.html

Diálogos Y Notificaciones
Nuestras aplicaciones siempre deben mostrar mensajes de alerta, procesamiento o

espera por algún proceso en ejecución, por ellos debemos hacer uso de las
funcionalidades para emitir mensajes o solicitudes de confirmación de nuestra
aplicación.
Entre los mensajes más comunes que tenemos tres tipos de notificaciones:
 Notificaciones Toast.
 Notificaciones en la barra de estado.
 Ventanas de diálogo.
Notificaciones Toast
Una notificación Toast es un mensaje emergente que se muestra superpuesto en la

pantalla. Solo ocupa el espacio necesario para mostrar la alerta, mientras tanto, la
actividad que estaba visible puede seguir usándose. Este tipo de notificaciones se
muestran durante un periodo de tiempo y desaparecen, no permiten interactuar con

ellas. Debido a que un Toast se crea mediante un servicio en segundo plano, puede
aparecer aunque la aplicación no esté visible.
A lo largo de todas las entradas sobre Android, se ha usado mucho este típo de
notificaciones:
Sintaxis
Toast.makeText(context, text, duration).show();
Context: Para pasar el contexto, tenemos varias posibilidades, NombreActividad.this,

o getApplicationContext().
Text: cadena de texto a mostrar
Duration: es el tiempo de duración puede asumir dos posibles valores tiempo corto o largo,
para ello podemos usar, una de las dos constantes predefinidas, Toast.LENGTH_SHORT ó
Toast.LENGTH_LONG en este caso, vamos a crear un layout personalizado para mostrar el
Toast:
< ?xml version="1.0" encoding="utf-8"?>

<linearlayout xmlns:android="http://schemas.android.com/apk/res/android"
android:id="@+id/toastLayout"
android:orientation="horizontal"
android:padding="10dp"
android:background="#DAAA"
>
<imageview android:layout_width="48px"
android:layout_height="48px"
android:src="@drawable/ok"
android:padding="5dip"
android:id="@+id/ok"/>
<textview android:id="@+id/textview"
android:text="Toast con layout personalizado"
android:textColor="#fff"
android:gravity="center_vertical|center_horizontal"/>
</linearlayout>
Se debe asignar un id al LinearLayout, que usaremos posteriormente. También hemos

creado un ImageView para mostrar un icono, y un TextView para mostrar el mensaje.
El siguiente paso es inflar este layout desde el código:
LayoutInflater inflater = getLayoutInflater();

View layout = inflater.inflate(
R.layout.toast_layout
,(ViewGroup) findViewById(R.id.toastLayout));

Toast toast = new Toast(getApplicationContext());

toast.setGravity(Gravity.CENTER_VERTICAL, 0, 0);
toast.setDuration(Toast.LENGTH_LONG);
toast.setView(layout);
toast.show();
Listo, al ejecutar la aplicación tendremos un Toast como este:
Para saber más acerca de los mensajes toast puede

visitar: http://developer.android.com/guide/topics/ui/notifiers/toasts.html
Notificaciones en la barra de estado
Este tipo de notificaciones muestran un icono en la barra de estado, cuando

desplegamos esta barra, veremos el icono acompañado de un texto descriptivo
indicando que ha pasado algo (Como que hemos recibido un nuevo mensaje, o un
correo electrónico).
Los pasos necesarios para crear este tipo de notificaciones son, usar el gestor de
notificaciones del sistema (NotificationManager) y posteriormente crear un objeto
Notification en el que configuraremos nuestra notificación. Vamos a ver como hacerlo.
NotificationManager mNotificationManager =
(NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
//Agregando el icono, texto y momento para lanzar la notificación

int icon = R.drawable.ok;
CharSequence tickerText = "Notification Bar";

long when = System.currentTimeMillis();
Notification notification = new Notification(icon, tickerText, when);
Context context = getApplicationContext();

CharSequence contentTitle = "Notificación en barra";
CharSequence contentText = "Mensaje corto de la notificación";
//Agregando sonido
notification.defaults |= Notification.DEFAULT_SOUND;
//Agregando vibración
notification.defaults |= Notification.DEFAULT_VIBRATE;
Intent notificationIntent = new Intent(this, NotificacionesActivity.class);

PendingIntent contentIntent = PendingIntent.getActivity(this, 0, notificationIntent, 0);
notification.setLatestEventInfo(context, contentTitle, contentText, contentIntent);
mNotificationManager.notify(HELLO_ID, notification);
El resultado es el siguiente:
Al igual que los Toast, se puede crear un layout personalizado, para más
información visita:
http://developer.android.com/guide/topics/ui/notifiers/notifications.html

Diálogos
Los cuadros de dialogo personalizado permiten realizar operaciones como
confirmación o ingresar algún dato en una ventana de dialogo existen varios tipos
entre ellos tenemos:
 AlertDialog
 ProgressDialog
 DatePickerDialog
 TimePickerDialog
Si necesitamos un Diálogo que no sea uno de los de arriba, podemos extender de la

clase Dialog, y crear el nuestro propio.
La clase Activity implementa métodos para gestionar los dialogos, son:
 onCreateDialog(int): Encargado de crear el diálogo.
 onPrepareDialog(int): Llamado justo antes de mostrarlo.
 showDialog(int): Para mostrarlo.
 dismissDialog(int): cierra el diálogo, guardando su estado.
 removeDialog(int): cierra el dialogo elminándolo por completo.
Ejemplo de AlertDialog
Mostrar una ventana de dialogo que preguntará si queremos salir de la aplicación
AlertDialog.Builder dialog = new AlertDialog.Builder(this);
dialog.setMessage("¿Salir?");
dialog.setCancelable(false);
dialog.setPositiveButton("Si", new DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialog, int which) {
NotificacionesActivity.this.finish();
}
});
dialog.setNegativeButton("No", new DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialog, int which) {
dialog.cancel();
}
});
dialog.show();

Ejemplo es ProgressDialog
Cuadro de dialogo que nunca termina.
ProgressDialog.show(
NotificacionesActivity.this
,"ProgressDialog"
,"Ejemplo diálogo de progreso"
,true
,true);
Los dos últimos parámetros son para que el diálogo

sea indeterminado, y para que se pueda cerrar con la
flecha de “atrás” del terminal.
Diseño diálogos
La clase principal que se usa para crear diálogos es la clase Dialog, pero no se
recomienda usar de manera directa dicha clase. Lo recomendable es usar una de las
siguientes subclases:
AlertDialog: Un diálogo que puede mostrar un título, un máximo de tres botones, una
lista de items o un layout personalizado.
DatePickerDialog o TimePickerDialog: Un diálogo con una interfaz predefinida que
permite al usuario seleccionar una fecha o una hora.
Estas clases definen el estilo y la estructura de tu diálogo, pero la

clase DialogFragment será usada como contenedor del diálogo. Dicha clase

proporciona todos los controles que necesitamos para crear un diálogo y modificar su
apariencia. La clase DialogFragment fue introducida en Android 3.0 (API 11), si usas
una versión más antigua, podrás usar la clase DialogFragment, para ver más detalles
ingresar al siguiente link: http://developer.android.com/tools/support-library/index.html
La clase DialogFragment te asegura la correcta gestión de los eventos que puedan

ocurrir, como por ejemplo pulsar el botón Atrás o rotar la pantalla. Además, usando
dicha clase podemos reusar el interfaz de los diálogos como componente en un
interfaz más grande.
Ejemplo de AlertDialog (Diseño de pantalla)
La metodo que sedebe agregar en la activity (MainActivity)

Código del botón de comando
Finalmente al ejecutar la aplicación y dar click en el botón de comando

Caso: Usando DialogFragment

Agregar una clase llamada GenerarVentanaDialogo
El código es el siguiente:

Posterior a ello agregar un botón de comando en el layout principal
Código del botón de comando Dialogo Fragment
La funcionalidad en ejecución

MENÚS
Los menús en las aplicaciones son algo que encontramos frecuentemente, de hecho,
casi todos los terminales Android tienen un botón específico para desplegarlos.
Se dispone de distintos tipo de menús:
Options Menu
El menú típico, que se despliega al pulsar la tecla menú, que se divide en dos grupos:
Icon menú
Muestra un menú con iconos, 6 elementos como máximo.
Expanded Menu
Se usa cuando hay más de 6 elementos, mostrando un elemento con la palabra ‘Más’.
Context Menu: Menús contextuales desplegados al realizar una pulsación

larga en una View.
Submenús: Menús desplegados al pulsar sobre un elemento de otro menú.
Options Menu
Lo más simple y sencillo es definir los menús en XML, colocado en ./res/menu, para
este ejemplo se ha definido el siguiente menu, que contiene dos elementos, un Acerca
de y un Salir:
< ?xml version="1.0" encoding="utf-8"?>
<menu xmlns:android="http://schemas.android.com/apk/res/android">
<item android:id="@+id/AcercaDe"
android:icon="@drawable/AcercaDe"
android:title="Acerca de la aplicación">
<menu xmlns:android="http://schemas.android.com/apk/res/android">
<item android:id="@+id/submenu"
android:title="Submenú de Salir"/>
</menu>
</item>
<item android:id="@+id/BtnSalir"
android:title="Salir"
android:icon="@drawable/BtnSalir"/>
</menu>
Detallaremos el código creado líneas arriba, comenzamos declarando el menú con la

etiqueta, que contendrá todos sus elementos bajo la etiqueta, en este caso, también
tenemos un submenu, que se declara igual que el menú principal.
Los atributos de cada elemento son su identificador, el icono a mostrar y el título.

Para poder usar este menú, necesitamos inflarlo (Convertir el fichero XML en un objeto
java), para hacer esto, hay que llamar a MenuInflater.inflate(), el código siguiente infla
el fichero xml anterior en el método callback onCreateOptionsMenu().
@Override
public boolean onCreateOptionsMenu(Menu menu) {
MenuInflater inflater = getMenuInflater();
inflater.inflate(R.menu.ejemplo_menu, menu);

return true;
}
Ahora, tenemos que responder a las acciones del usuario cuando pulse algún
elemento de nuestro menú, para ello vamos a sobreescribir el
método onOptionsItemSelected()
@Override
public boolean onOptionsItemSelected(MenuItem item) {
switch (item.getItemId()) {
case R.id.AcercaDe:
Toast.makeText(
MenusActivity.this
,"Ejemplo Menú"
,Toast.LENGTH_LONG)
.show();
return true;
case R.id.quit:
finish();
return true;
default:
return super.onOptionsItemSelected(item);
}
}
Context Menu
Los menús contextuales son similares a los menús mostrados al hacer click con el
botón derecho de un ratón en un PC, para crearlos, debemos sobreescribir el
método onCreateContextMenu(), donde inflaremos el archivo xml.
@Override
public void onCreateContextMenu(ContextMenu menu, View v,
ContextMenuInfo menuInfo) {
super.onCreateContextMenu(menu, v, menuInfo);
MenuInflater inflater = getMenuInflater();
inflater.inflate(R.menu.ejemplo_menu, menu);
}
Al igual que en los options menu, tenemos que responder a las acciones del usuario:
@Override
public boolean onContextItemSelected(MenuItem item) {
switch (item.getItemId()) {
case R.id.AcercaDe:
Toast.makeText(
MenusActivity.this
,"Ejemplo Menús App"
,Toast.LENGTH_LONG)
.show();
return true;
case R.id.Salir:
finish();
return true;
default:

}
}
Pero este menú contextual no se va a mostrar, ya que tenemos que asociarlo para que
se lanze al realizar una pulsación prolongada sobre una view, en este caso un botón:
final Button boton = (Button) findViewById(R.id.button1);
registerForContextMenu(boton);

UNIDAD
3
PERSISTENCIA DE DATOS EN
ANDROID
Al término de la unidad, el alumno elabora aplicaciones que manejan recursos,
archivos XML, y manejan bases de datos SQLite.
TEMARIO
3.1 Acceso a recursos y archivos

3.1.1 Persistencia de datos: Files
3.1.2 Almacenamiento privado y compartido.
3.1.3 File, FileOutputStream, OutputStreamWriter, PrintWriter
3.1.4 Environment uso de métodos básicos para acceso a recursos.
3.1.5 Grabar y cargar datos de Preferencias de Usuario.
3.1.6 Leer XML Data usando SAX and W3C Parsers.
3.2 Persistencia de Datos usando SQLite

3.2.1 Introducción a SQLite
3.2.2 Gestión de bases de datos con SQLite. Uso del componente
SQLiteOpenHelper.
3.2.3 Métodos y funciones comunes, Insert, Update, Delete, RawQuery,
SQLExec
3.3 Aplicando el Modelo Vista controlador con SQLite

3.3.1 La clase ContentValues
3.3.2 Introducción a SQLite: cursores y contenedores de valores.
3.3.3 Clases de acceso a datos basados en el modelo vista controlador.
3.3.4 Buenas prácticas de bases de datos en SQLite
3.3.5 Creando un proyecto con acceso a bases de datos

Acceso a recursos y archivos
Android al igual que otros sistemas operativos maneja un sistema de archivos basado
en el nucleo del sistema operativo base Linux 2.6, por ello para acceder a los archivos
y/o recursos del sistema operativo se debe indicar los permisos que debe tener la
aplicación, además de ello se debe especificar eel espacio de almacenamiento que se
tendrá en la aplicación cuando se crea una maquina virtual en los dispositivos de
prueba. A continuación se presenta un ejemplo de configuración de espacio de
almacenamiento que se debe realizar al momento de configurar la maquina virtual.
En Android tenemos las siguientes formas de acceso a recursos y/o archivos
 La memoria interna del dispositivo.

 La tarjeta SD externa, si existe.
 La propia aplicación, en forma de recurso.
Memoria Interna
Android permite leer y escribir datos en ficheros de la memoria interna a través de los
métodos habituales para trabajar con ficheros en Java. También nos permite hacer

uso del directorio de cache para tales usos, pero hay que ser precavidos ya que la
chache tendremos que manejarla nosotros y abusar mucho de este directorio puede
ralentizar nuestra aplicación.
Memoria Externa
Casi todos los dispositivos Android soportan el uso de memoria externa ya sea en
forma de tarjeta SD o no. Hay que tener en cuenta que cualquier archivo en esta
memoria es accesible a todo el mundo, es decir, cualquier aplicación puede leer y
escribir ahí. Al contrario que la memoria interna, en la memoria externa necesitamos
solicitar permisos en el Manifest para tener acceso a ella.
Base de Datos SQLite

Android provee soporte completo para base de datos de tipo SQLite. Se trata de un
tipo de base de datos muy pequeña y ligera ya que está basada en ficheros, por eso
es ampliamente utilizada en sistemas móviles. Para ayudarnos a gestionar la base de
datos Android recomienda hacer uso de la clase de ayuda que nos proporciona
SQLiteOpenHelper.
En las clases de persistencia hicimos un recorrido completo sobre cómo usar una base
de datos en Android. Desde los primeros pasos, creando las estructuras de datos y
tablas, hasta la gestión de las mismas creando una clase que herede de
SQLiteOpenHelper e implementando los métodos para gestionar nuestra base de
datos: leyendo, guardando, actualizando y borrando registros en las tablas.
Además de todo esto estudiamos buenas prácticas a la hora de trabajar con base de
datos y tuvimos una aproximación a otra técnica para gestionarlas: los ORM. Esta
técnica realiza un mapeo de las entidades relacionales de la base de datos a objetos.
Proveedor de contenido o Content Provider
Un proveedor de contenidos permite compartir y tener acceso a información de otras

aplicaciones. Se accede a ellos a través de sus Content URIs, que no son más que
cadenas de texto al estilo de las direcciones web. Se implementan heredando de
ContentProvider pero se accede a ellos a través de objetos ContentResolver. Su
utilización es similar a la de una base de datos pero no tienen por qué brindar acceso
a una base de datos. Entre los que probamos estaban el Contact Provider, Calendar
Provider y Media Provider, que nos proporcionan acceso a información de contactos,
calendario y multimedia respectivamente.

Entre las clases más conocidas para manejar archivos tenemos las siguientes clases:
• Para almacenar información en archivos android presenta varias opciones
entre ellos tenemos:
 Shared Preferences Almacenar datos primitivos privadas en pares clave-valor
 Internal Storage Guarde los datos privados en la memoria del dispositivo.
 External Storage Guarde los datos públicos sobre el almacenamiento externo
compartido.
 SQLite Databases Guarde los datos estructurados en una base de datos
privada.
 Network Connection Almacenar datos en la web con su propio servidor de
red,
 Content Provider Repositorio compartido globalmente compartida por todas
las aplicaciones.
Para tener acceso a leer y escribir archivos debemos asignar los permisos en el
archivo de manifiesto como por ejemplo se presenta en el siguiente grafico:
Ejemplo de creación de un archivo llamado prueba_int.txt en la memoria interna de

modo privado.

Siempre que se genera el archivo de modo privado se almacena en la siguiente

ubicación:
/data/data/nombre_package/files/nombre_fichero
Para el ejemplo mostrado se almacena en:

/data/data/ solucionesmoviles.archivos/files/prueba_int.txt
Shared Preferences
 getPreferences( )
Desde dentro de su actividad, a las preferencias específicas de la actividad de
acceso
 getSharedPreferences( )
Desde dentro de su actividad para acceder a las preferencias a nivel de
aplicación
 getDefaultSharedPreferences( )
En PreferencesManager, para obtener las preferencias compartidas que
funcionan en concierto con el marco de la preferencia general de Android
Todos los métodos de preferencias getXXX devolver un objeto Preferencia cuyo

contenido puede ser manipulado por un editor que permite putXxx ... y ... getXXX
comandos para colocar los datos de entrada y salida del contenedor Preferencia

Ejemplo: Diseño de pantalla

Código fuente de la aplicación

Creando carpetas
El siguiente ejemplo muestra como crear una carpeta llamada miBkApp en la carpeta
de almacenamiento externo

Leer un archivo de disco
Para el siguiente ejemplo vamos a continuar con nuestro proyecto inicial creado, para
ello vamos a agregar un botón nuevo que tenga de titulo grabar archivo y de nombre
tendrá BtnGrabarArchivo
El código de la aplicación será la siguiente:

Environment
Representa las variables del entorno, tiene propiedes comunes para toda la aplicación
Tiene propiedades comunes que utilizaremos para tener las rutas hacia a la carpeta de
nuestro celular, carpeta de imágenes, recursos, carpeta de SD externo o la carpeta
Root del sistema operativo entre otros.
El siguiente grafico muestra los atributos más comunes de esta clase.
Public Metodo/Función
Methods
getDataDirectory()
static File Recupera la carpeta de datos del usuaurio activo.
getDownloadCacheDirectory()
static File Recupera la carpeta de descargas.
getExternalStorageDirectory()
Recupera el nombre y ruta de la carpeta de la tarjeta SD
Get a top-level public external storage directory for placing files of a
static File particular type.
getExternalStorageState(File path)
Devuelve el estado actual del dispositivo de almacenamiento que
static String proporciona la ruta indicada.
getExternalStorageState()
Devuelve el estado actual del dispositivo de almacenamiento primario
static String "externa".
static isExternalStorageEmulated()
boolean Indica si el dispositivo de almacenamiento " externa" primaria es
emulado.

Adaptadores de datos (Adapters)
Un adaptador es una clase especial que hace de intermediario entre un contenedor

como un listview u otro para cargar información en una plantilla por ejemplo un
adaptador podemos utilizarlo para poblar un listview como se puede mostrar en el
siguiente grafico donde se carga la lista de docentes registrados en una base de datos
Ejemplo de un arrayAdapter para cargar una lista de datos en un control Spinner

(ComboBox)

Grafico que muestra la funcionalidad del spinner con datos cargados
Otro Ejemplo de un adaptador es aquel que se usa para cargar datos

personalizados en un listview haciendo uso de un layout personalizado
Esta clase adaptador es una clase que se debe cargar a nivel del Mainactivity para
poderlo utilizar para cargar el listview
Para profundizar este tema lo veremos después de ver SQLite que se vera en el
siguiente tema.

Introducción a SQLite
SQLitees un sistema de gestión de bases de datos relacional compatible con ACID,

contenida en una relativamente pequeña (~275 kiB)2 biblioteca escrita en C. SQLitees
un proyecto de dominio público1 creado por D. Richard Hipp. Para más detalles
puedes ingresar a la página oficial de SQLite www.sqlite.org
Caracteristicas principales
 Base de datos relacional para sistemas embebidos

 Ocupa únicamente unos 225KB
 No se trata de un proceso, sino de una librería que se añade dinámicamente a
las aplicaciones que quieren utilizar SQLite
 Implementa la mayor parte del estándar SQL-92, pero con restricciones
 Soporte para ALTER_TABLE limitado
 Las columnas no tienen tipos
 Existen un pluginde Firefox para visualizar bases de datos
SQLite(recomendado)
 Se utiliza internamente en Firefox y Thunderbird
 Lo utilizan la mayoría de las plataformas móviles (iOS, Symbian, Android,
BlackBerry OS, webOS)
 Existen múltiples formas de atacar SQLite
 Nosotros veremos una en la que separamos el acceso a la base de datos del
objeto Java que representa cada fila de la base de datos
 No existen las claves ajenas o foráneas, y en el caso de necesitarlas, debemos
forzarlas “a mano”
 La base de datos está protegida dentro de la memoria interna del dispositivo
 Mientras trabajamos con el emulador (donde tenemos acceso root), podemos
extraer (con DDMS) el archivo de la base de datos y visualizarlo
Cuando se crea un archivo de bases de datos se almacena de manera muy similar

que los archivos en disco:
 "/data/data/packake/nombrebasedatos.db"
Donde la carpeta principal es la carpeta de datos.

Packake es el nombre del paquete de la aplicación creada.
Ejemplo de crear un archivo de bases de datos
String StrRutaBaseDatos="/data/data/sise.app.BaseDatos/Contacto.db";
SQLiteDatabaseodb=SQLiteDatabase.openDatabase(StrRutaBaseDatos,
null,SQLiteDatabase.CREATE_IF_NECESSARY);

Tipos de datos
Integer
Valor entero, almacena1, 2, 3, 4, 6, o 8 bytes dependede la magnituddel campo.
Real
Valoresnúmericosdecimales8-byte punto flotante.
Text
Se almacenacadena en código (UTF-8, UTF-16BE or UTF-16LE).
Para más detalles y otros tipos de datos puedes ir al portal oficional de tipos de datos:
http://www.sqlite.org/datatype3.html
Metodos principales
Entre los métodos principales tenemos los siguientes
execSQL
Ejecuta un sentencia sql de creación de datos create, drop, etc.
Ejemplo:
Otros Ejemplos:
Importante!
SQLITE usaun campo ivisiblellamadoROWID queidentificacomounicoregistrola filaen el

ejemplose usaCodigocomoun campo similar

RawQuery(SentenciaSQL, ParametrosArreglo)
Esta función permite recuperar un cursor (tabla) con el fin de cargar los datos en un
adaptador para presentarlo en un contenedor como un listview
Ejemplo
Cursor c1 = db.rawQuery("select count(*) as Total from tblAMIGO",null);
Agregando parámetros a Rwquery
String mySQL= "select count(*) as Total "

+ " fromContacto"
+ " whereCodigo> ?"
+ " and Nombre= ?";
String[] args= {"1", «Juan"};
Cursor c1 = db.rawQuery(mySQL, args);
Ejemplo de rwaquery:
Ejemplo Cargando Datos en una clase

La clase ContentValues
Esta clase permite almacenar variables de tipo diccionario es decir un nombre de

variable y un valor de la variable, se utiliza para pasar los datos a una base de datos y
ejecutar las sentencias de mantenimiento de datos en una base de datos de SQLite
Ejemplo: Clase especial de tipo campo valor de valores únicos controlados por índice
útil para hacer uso de insertar y/o actualizar los registros en la base de datos.
Sintaxis
ContentValues oRegistro=new ContentValues();
Metodo de SQLite insert
Ejecuta la sentencia SQL insert para agregar un nuevo registro en la base de datos
Sintaxis
insert(table, nullColumnHack, values)
Donde:
Table.- Nombre de tabla
nullColumnHack.- indica que campos tienen soporte a nulos
Values.- Lista de campos con valores a insertar
Ejemplo:
Metodo de SQLite update

Permite actualizar datos de una tabla, Ejecuta la sentencia SQL update para actualizar
registros de la base de datos
Sintaxis
update(table, values, whereClause, whereArgs)
Donde:
Values.- Lista de campos con valores a insertar

whereClause.- Parámetros para actualizar e registro en modificación

whereArgs.- Valores par los campos de parámetros
Ejemplo:
Metodo de SQLite delete
Ejecuta la sentencia SQL delete para eliminar un registro de la base de datos
Sintaxis
delete(table, whereClause, whereArgs)
Donde:
whereClause.- Parámetros para actualizar e registro en modificación
whereArgs.- Valores par los campos de parámetros
Ejemplo:
La clase Cursor
Representa un objeto tabla en la aplicación

Sintaxis
Cursor oTabla=oDb.rawQuery("select * from Alumno", null);
Ejemplo:
Metodos
getColumnCount().- Permite saber el número de columnas que tiene la(s) tablas
consultada(s).
close().- Permite cerrar el cursor que se encuentra abierto.
getColumnName(columnIndex).- permite leer el nombre de una columna a partir del
índice
getCount().- permite leer el número de registros existentes en el cursor.

getDouble(columnIndex).- permite leer el valor de un campo número con decimales

de tipo doublé.
getString(columnIndex).- permite leer el valor de un campo de tipo cadena varchar,
text nvarchar
getInt(columnIndex).- Permite leer el valor de un campo de tipo entero
getFloat(columnIndex).- Permite leer el valor de un campo de tipo número con
decimales float.
Modelo Vista Controlador
Para aquellos que no estén familiarizados con el MVC, éste es un patrón que divide la
aplicación en tres niveles distintos, interfaz gráfica (Vista), tratamiento de datos
(Modelo) lógica de negocio (Controlador). Esto se hace para permitir una mayor
portabilidad de una aplicación, e incluso facilitar su mantenimiento. Por ejemplo si
deseamos modificar la interfaz de la aplicación es decir solo pantallas sólo
prestaremos atención a la capa de la Vista, y si queremos modificar de sistema de
almacenamiento de datos sólo tendremos que prestar atención a la capa del Modelo, y
si lo que queremos es portar la aplicación a otra plataforma lo que haremos será
modificar la capa del Controlador, al igual que si queremos modificar el código para
optimizar rendimiento.
Figura: modelo vista controlador

Fuente:http://www.proyectosimio.com/es/programacion-android-base-de-datos-i-modelo-vista-controlador/

Interfaz Grafica
(Vista(
Activity
Controlador
Aplication
Controlador
SQLite
Modelo
Paso 1: Sobreescribir la aplicación
Debemos crear una nueva clase. Le damos al botón derecho sobre el Package que
tenemos en la estructura de nuestro proyecto, New->Class y le damos un nombre a
nuestra nueva clase que haga referencia a su función. Es una buena práctica crear
diferentes packages para los distintos tipos de clases que vayamos a crear, por
ejemplo un package para las Activities, otro package.modelo para las clases que
representen los datos que necesitemos manejar (por ejemplo una clase Auto), etc.
Una vez que tenemos la clase creada, le diremos que extienda de Application:
Paso 2: Modificar el archivo de manifiesto

Se debe realizar este paso para configurar que nuestra nueva clase será la que llama
a todos los activitys a a partir de ahora
Antes estaba así
Debe quedar como se muestra
Paso 3: Llamar a nuestra aplicación

Para hacer llamadas a los métodos que necesitemos de la clase Application que
hemos definido. Para poder hacerlo las Activities ya cuentan con un método que llama
a la claseApplication, que es getApplication(), que nos va a devolver precisamente la
clase Application. Sin embargo para poder hacer uso de los métodos que definamos

en nuestra clase vamos a tener que hacer una conversión al tipo de la clase que
nosotros hemos definido como Application, y a partir de ahí podremos hacer la llamada
a los métodos que contenga la clase. Para que quede más claro un ejemplo sería:
((MyApplication)getApplication()).metodoDeNuestraClaseApplication();
// Llamada desde la Activity al método de Application
((MyApplication)getApplication()).getNombre()
// Código del método en MyApplication

String getNombre(int idContacto) {
return modelo.getNombre(idContacto);
}

UNIDAD
4
NETWORKING EN ANDROID
Al término de la unidad, el alumno elabora aplicaciones que se conectan a la
web utilizando http y consumen servicios web.
TEMARIO
4.1 Consumiendo servicios web

4.1.1 SOAP (Simple Object Access Protocol) Mensajes SOAP, Estructura
4.1.2 Uso del protocolo HTTP para consumir web services.
4.1.3 Obtención de data de archivos XML.
4.1.4 Crear y consumir web services.

Servicios web
Los servicios web permiten integrar aplicaciones de distintas plataformas como puede
ser la plataforma Java con la plataforma .net o viceversa, estos fueron creados con el
fin de ampliar la posibilidad de distribuir información mediante la web. Según la W3c lo
defie como “Un Servicio Web (Web Service [WS]) es una aplicaci´on software
identificada por un URI (Uniform Resource Identifier), cuyas interfaces se pueden
definir, describir y descubrir mediante documentos XML. Los Servicios Web hacen
posible la interacción entre ”agentes” software (aplicaciones) utilizando mensajes XML
intercambiados mediante protocolos de Internet.”
Un Servicio Web es un componente software que puede ser registrado, descubierto e

invocado mediante protocolos estándares de Internet.
 Permiten exponer y hacer disponibles funcionalidades (servicios) de los
sistemas informáticos de las organizaciones mediante tecnologías y protocolos
WEB estándar.
 Cada Servicio Web se responsabilida de realizar un conjunto de funciones
concretas y bien definidas.
 Los Servicios Web actúan como componentes independientes que se pueden
integrar para formar sistemas distribuidos complejos.
Modelo de funcioamiento de los web services

Cuando una empresa como un banco desea comunicarse sus sistemas con una
empresa aseguradora, el banco publica un servicio web y la empresa aseguradora
utiliza el servicio es decir la consume para realizar operaciones con el banco. El
siguiete grafico muestra el modo de operar de un servicio web para ello se emplea
datos en el lenguaje XML, la definición denominado esquema y utilizando un protocolo
de comunicaciones denominado SOAP.

Según el ejemplo del gráfico, un usuario (que juega el papel de cliente dentro de
los Servicios Web), a través de una aplicación, solicita información sobre un
viaje que desea realizar haciendo una petición a una agencia de viajes que
ofrece sus servicios a través de Internet. La agencia de viajes ofrecerá a su
cliente (usuario) la información requerida. Para proporcionar al cliente la
información que necesita, esta agencia de viajes solicita a su vez información a
otros recursos (otros Servicios Web) en relación con el hotel y la compañía
aérea. La agencia de viajes obtendrá información de estos recursos, lo que la
convierte a su vez en cliente de esos otros Servicios Web que le van a
proporcionar la información solicitada sobre el hotel y la línea aérea. Por último,
el usuario realizará el pago del viaje a través de la agencia de viajes que servirá
de intermediario entre el usuario y el servicio Web que gestionará el pago.
En todo este proceso intervienen una serie de tecnologías que hacen posible
esta circulación de información. Por un lado, estaría SOAP (Protocolo Simple de
Acceso a Objetos). Se trata de un protocolo basado en XML, que permite la
interacción entre varios dispositivos y que tiene la capacidad de transmitir
información compleja. Los datos pueden ser transmitidos a través
de HTTP ,SMTP , etc. SOAP especifica el formato de los mensajes. El mensaje
SOAP está compuesto por un envelope (sobre), cuya estructura está formada
por los siguientes elementos: header (cabecera) y body (cuerpo).

Figura: Estructura de los mensajes
Fuente: http://www.w3c.es/Divulgacion/GuiasBreves/ServiciosWeb
Para optimizar el rendimiento de las aplicaciones basadas en Servicios Web, se

han desarrollado tecnologías complementarias a SOAP, que agilizan el envío de
los mensajes (MTOM) y los recursos que se transmiten en esos mensajes
(SOAP-RRSHB).
Por otro lado, WSDL (Lenguaje de Descripción de Servicios Web), permite que
un servicio y un cliente establezcan un acuerdo en lo que se refiere a los
detalles de transporte de mensajes y su contenido, a través de un documento
procesable por dispositivos. WSDL representa una especie de contrato entre el
proveedor y el que solicita. WSDL especifica la sintaxis y los mecanismos de
intercambio de mensajes.
Durante la evolución de las necesidades de las aplicaciones basadas en

Servicios Web de las grandes organizaciones, se han desarrollado mecanismos
que permiten enriquecer las descripciones de las operaciones que realizan sus
servicios mediante anotaciones semánticas y con directivas que definen el
comportamiento. Esto permitiría encontrar los Servicios Web que mejor se
adapten a los objetivos deseados. Además, ante la complejidad de los procesos
de las grandes aplicaciones empresariales, existe una tecnología que permite
una definición de estos procesos mediante la composición de varios Servicios
Web individuales, lo que se conoce como coreografía.
Ejemplos
A continuación se muestra el código que se utilizaría para solicitar un viaje:
<?xml version='1.0' ?>

<env:Envelope xmlns:env="http://www.w3.org/2003/05/soap-
envelope">

<env:Header>
<m:reserva xmlns:m="http://empresaviajes.ejemplo.org/reserva"
env:role="http://www.w3.org/2003/05/soap-envelope/role/next"
env:mustUnderstand="true">
<m:referencia>
uuid:093a2da1-q345-739r-ba5d-pqff98fe8j7d
</m:referencia>
<m:fechaYHora>2001-11-29T13:20:00.000-
05:00</m:fechaYHora>
</m:reserva>
<n:pasajero xmlns:n="http://miempresa.ejemplo.com/empleados"
env:role="http://www.w3.org/2003/05/soap-envelope/role/next"
env:mustUnderstand="true">
<n:nombre>Pepe Ejemplo</n:nombre>
</n:pasajero>
</env:Header>
<env:Body>
<p:itinerario
xmlns:p="http://empresaviajes.ejemplo.org/reserva/viaje">
<p:ida>
<p:salida>Nueva York</p:salida>
<p:llegada>Los Angeles</p:llegada>
<p:fechaSalida>2001-12-14</p:fechasalida>
<p:horaSalida>última hora de la tarde</p:horaSalida>
<p:preferenciaAsiento>pasillo</p:preferenciaAsiento>
</p:ida>
<p:vuelta>
<p:salida>Los Angeles</p:salida>
<p:llegada>Nueva York</p:llegada>
<p:fechaSalida>2001-12-20</p:fechaSalida>
<p:horaSalida>media-mañana</p:horaSalida>
<p:preferenciaAsiento/>
</p:vuelta>
</p:itinerario>
<q:alojamiento
xmlns:q="http://empresaviajes.example.org/reserva/hoteles">
<q:preferencia>ninguna</q:preferencia>
</q:alojamiento>
</env:Body>
</env:Envelope>

Estructura Mensaje SOAP
Un mensaje SOAP es un documento XML ordinario con una estructura definida en la

especificación del protocolo.
Definición del Mensaje SOAP (WSDL)

WSDL son las siglas de Web Services Description Language, un formato XML que se
utiliza para describir servicios Web.
WSDL se usa a menudo en combinación con SOAP y XML Schema
Estructura del WSDL

Tipos de Datos
 <types>: Esta sección define los tipos de datos usados en los mensajes.
Mensajes
 <message>: Aquí definimos los elementos de mensaje.
Tipos de Puerto
 <portType>: Con este apartado definimos las operaciones permitidas y los
mensajes intercambiados en el Servicio.
Bindings
 <binding>: Especificamos los protocolos de comunicación usados.
Servicios
 <service>: Conjunto de puertos y dirección de los mismos.

Caso:
Crear un web Service usando visual studio 2010
Nombre de proyecto: WSLogin

Ubicación: C:\Android_2015
Agregar un web Service menú proyect/Add new Item
Vista del proyecto
Código fuente de wslogin.asmx

El método WebMethod con dos parámetros pUsuario y pContrasenia
Web Service en publicación
Donde:
(1) Al dar click e ServiceDescriptión
Muestra la definición de servicio como métodos y funcionalidades como
métodos públicos parámetros y tipos de datos

<wsdl:definitions xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/" xmlns:tm="http://microso

ft.com/wsdl/mime/textMatching/" xmlns:soapenc="http://schemas.xmlsoap.org/soap/encoding/"x
mlns:mime="http://schemas.xmlsoap.org/wsdl/mime/" xmlns:tns="http://tempuri.org/" xmlns:s="h
ttp://www.w3.org/2001/XMLSchema" xmlns:soap12="http://schemas.xmlsoap.org/wsdl/soap12/"
xmlns:http="http://schemas.xmlsoap.org/wsdl/http/" xmlns:wsdl="http://schemas.xmlsoap.org/ws
dl/" targetNamespace="http://tempuri.org/">
<wsdl:types>
<s:schema elementFormDefault="qualified" targetNamespace="http://tempuri.org/">
<s:element name="HelloWorld">
<s:complexType/>
</s:element>
<s:element name="HelloWorldResponse">
<s:complexType>
<s:sequence>
<s:element minOccurs="0" maxOccurs="1" name="HelloWorldResult" type="s:string"/>
</s:sequence>
</s:complexType>
</s:element>
<s:element name="ValidarUsuario">
<s:complexType>
<s:sequence>
<s:element minOccurs="0" maxOccurs="1" name="pUsuario" type="s:string"/>
<s:element minOccurs="0" maxOccurs="1" name="pContrasenia" type="s:string"/>
</s:sequence>
</s:complexType>
</s:element>
<s:element name="ValidarUsuarioResponse">
<s:complexType>
<s:sequence>
<s:element minOccurs="1" maxOccurs="1" name="ValidarUsuarioResult" type="s:boolean"/>
</s:sequence>
</s:complexType>

</s:element>
</s:schema>
</wsdl:types>
(2) Metodos del servicio

Mustra los métodos públicos que se pueden consumir por el cliente e
nuestro caso utilizando Android, Dando un click por ejemplo en el
método Validar usuario se muestra la siguiente página para hacer
pruebas del servicio.
Adicionalmente se muestra formas de llamada de clientes:
Usando protocolo SOAP 1.1

Indica el nombre del método así como los parámetros que recibe y la respuesta que
emite la sección que tiene el nombre del método con la palabra Result ejemplo
ValidarUsuarioResponse y el tipo de dato de respuesta
<ValidarUsuarioResult>boolean</ValidarUsuarioResult>
Ejemplo de la imagen

Usando Protocolo SOAP 1.2 el mismo escenario indicado, sin embargo es para
soporte a plataformas complejas como WCF (Windows comuication fudation)

Clases de acceso a web service

Android no tiene ninguna librería para consumir web Service por ello debemos utilizar
una librería libre llamada ksoap para consumir nuestro web Service. Para utilizar la
librería se debe descargar desde:
https://code.google.com/p/ksoap2-android/
Dar click en download y descargar el jar que indica descarga directa.
Una vez descargado ponerlo en una carpeta con ruta corta como C:\AndroidDll
Clases, métodos y funciones

SoapObject
Permite realizar crear la conexión al servicio basado en el namespace y el nombre de
método
SoapObject oRequest=new SoapObject(“http://tempuri.org/”, “Sumar”);
addProperty
Propiedad de SoapObject para agregar parámetros
oRequest.addProperty("pNumero1",1);
oRequest.addProperty("pNumero2",2);
SoapSerializationEnvelope

Permite inicializar el enlace de datos con el web service, serializar los datos para
iniciar comunicación.
SoapSerializationEnvelope oSerializador=new
SoapSerializationEnvelope(SoapEnvelope.VER11);
oSerializador.setOutputSoapObject(oRequest);
oSerializador.dotNet=true;
HttpTransportSE
Permite realizar la llamada al servicio web utilizando la url y el objetito de serialización
HttpTransportSE oEjecutarWebService=new
HttpTransportSE(“http://planificador.nisabusiness.com/operaciones.asmx”);
oEjecutarWebService.call(“http://tempuri.org/Sumar”, oSerializador);
SoapObject Resultado=(SoapObject)oSerializador.bodyIn;
StrResultado=Resultado.getProperty(0).toString(); //Permite recuperar el dato.
Agregar la referencia en Android studio
Click e el menú archivo y luego dar click en

estructura de proyecto.
Dar click en agregar referecia

En la ventana que aparece seleccionar importar Jar como se muestra e el siguiente

grafico
Dar click e siguiente:

En esta ventana ubicar el archivo descargado
Posteriormente se debe seguir los pasos que se indica e la numeración para agregar
la referencia en el APK
Dar click en Apply y luego ok

Thread Manejando Hilos

E Android para las llamadas que pueden demorar el proceso de operación de las
aplicaciones se debe utilizar un hilo de ejecución por ello debemos revisar la
documentación de como manejar hilos.
Thread (Hilo).- Clase que permite ejecutar algún proceso en segundo plano.
Thread Ejemplo
Thread código de ejemplo
El siguiente código de ejemplo muestra como se utiliza el thead

Donde:
1.- es el diseño de la pantalla
2.- las variables a nivel de activity
3.- código del método principal del thead

Consumiendo web Service desde Android
Objetivo
Crear un web Service que permita realizar operaciones de suma y que retore el
resultado.
Paso 1: Crear en proyecto usado visual studio 2010

Utilizado el proyecto creado anteriormente
Agregar el webservice llamado Operaciones.asmx
El código fuente s el siguiente:
Ua vez ejecutado se muestra lo siguiente:

EL mismo web Service se encuentra publicado en la siguiente dirección:

http://planificador.nisabusiness.com/operaciones.asmx
Consumiendo web Service desde Android

Crear el proyecto WSLogin
Activity en Blanco
No olvidarse de dar permisos de acceso a internet
En el archivo de manifiesto AndroidManifest.xml

El layout principal es el siguiente:
<LinearLayout
xmlns:tools="http://schemas.android.com/tools"
android:id="@+id/LinearLayout1"
android:paddingBottom="@dimen/activity_vertical_margin"
android:paddingLeft="@dimen/activity_horizontal_margin"
android:paddingRight="@dimen/activity_horizontal_margin"
android:paddingTop="@dimen/activity_vertical_margin"
tools:context=".MainActivity">
<TableRow
android:id="@+id/tableRow1"
android:layout_height="wrap_content" >
<TextView
android:id="@+id/textView1"
android:text="@string/lbltitulo"
android:textAppearance="?android:attr/textAppearanceLarge" />
</TableRow>
<TableRow
<TextView
android:text="@string/lblTitulonumero1" />
<EditText
android:id="@+id/edtnumero1"
android:ems="10" >
<requestFocus />
</EditText>
</TableRow>
<TableRow
<TextView

android:text="@string/lbltitulonumero2" />
<EditText
android:id="@+id/edtnumero2"
android:ems="10" />
</TableRow>
<TableRow
<TextView
android:text="@string/lbltituloresultado" />
<TextView
android:id="@+id/tvresutado"
android:text="@string/lbltituloresultadofinal"
android:textAppearance="?android:attr/textAppearanceMedium" />
</TableRow>
<TableRow
<Button
android:id="@+id/btncalcular"
android:text="@string/lblbtntituloboton" />
<Button
android:id="@+id/btncancelar"
android:text="@string/btntitulocancelar" />
</TableRow>
</LinearLayout>

El diseño final de la pantalla es el siguiente:
Los nombres de los controles son los siguientes:

Código fuente
Código para el eveto click del botón de comando calcular
package solucionesmoviles.myapplication;
import android.app.Activity;
import android.os.Bundle;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;
import android.widget.Button;
import android.widget.EditText;
import android.widget.TextView;
import android.widget.Toast;
import org.ksoap2.SoapEnvelope;
import org.ksoap2.serialization.SoapObject;
import org.ksoap2.serialization.SoapSerializationEnvelope;
import org.ksoap2.transport.HttpTransportSE;
public class MainActivity extends Activity {
EditText oedtnumero1=null;
EditText oedtnumero2=null;
TextView oTvResultado=null;

Button obtnSumar=null;
Button obtnCancelar=null;
private static String NAMESPACE = "http://tempuri.org/";

private static String URL = "http://planificador.nisabusiness.com/operaciones.asmx";
private static String NOMBRE_METODO = "Sumar";
private static String SOAP_ACTION = "http://tempuri.org/Sumar";
@Override
protected void onCreate(Bundle savedInstanceState) {
setContentView(R.layout.activity_main);
obtnSumar=(Button)findViewById(R.id.btncalcular);
obtnSumar.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
// TODO Auto-generated method stub
Thread oHilo=new Thread()
{
String StrResultado="";
public void run()
{
oedtnumero1=(EditText)findViewById(R.id.edtnumero1);
oedtnumero2=(EditText)findViewById(R.id.edtnumero2);
SoapObject oRequest=new SoapObject(NAMESPACE, NOMBRE_METODO);
oRequest.addProperty("pNumero1",Integer.valueOf(oedtnumero1.getText().toString()));
oRequest.addProperty("pNumero2",Integer.valueOf(oedtnumero2.getText().toString()));
SoapSerializationEnvelope oSerializador=new
SoapSerializationEnvelope(SoapEnvelope.VER11);
oSerializador.setOutputSoapObject(oRequest);
oSerializador.dotNet=true;
HttpTransportSE oEjecutarWebService=new HttpTransportSE(URL);
try
{
oEjecutarWebService.call(SOAP_ACTION, oSerializador);
SoapObject Resultado=(SoapObject)oSerializador.bodyIn;
StrResultado=Resultado.getProperty(0).toString();
}
catch(Exception ex)
{
StrResultado=ex.toString();
}
runOnUiThread(new Runnable()
{
public void run()
{
oTvResultado=(TextView)findViewById(R.id.tvresutado);
oTvResultado.setText(StrResultado);
Toast.makeText(getBaseContext(), StrResultado,
Toast.LENGTH_LONG).show();
}
});
}
};
oHilo.start();

}
});
obtnCancelar=(Button)findViewById(R.id.btncancelar);
obtnCancelar.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
// TODO Auto-generated method stub
finish();
}
});
//getActivity().onBackPressed();
public void AplicandoHilos()

{
Thread oHilo=new Thread(
new Runnable()
{
public void run()
{//Metodo de ejecución
//Acceso a interfaz grafica actual

runOnUiThread(new Runnable()
{
public void run()
{}
});
}
}
);
oHilo.start(); //Ejecutar el hilo
}
@Override
public boolean onCreateOptionsMenu(Menu menu) {
// Inflate the menu; this adds items to the action bar if it is present.
getMenuInflater().inflate(R.menu.menu_main, menu);
return true;
}
@Override
public boolean onOptionsItemSelected(MenuItem item) {
// Handle action bar item clicks here. The action bar will
// automatically handle clicks on the Home/Up button, so long
// as you specify a parent activity in AndroidManifest.xml.
int id = item.getItemId();
//noinspection SimplifiableIfStatement
if (id == R.id.action_settings) {
return true;
}
}
}

Prueba de ejecución de aplicación

Ingresar los datos Una vez calculado se muestra el resultado

UNIDAD
5
Servicios basados en localización
Al término de la unidad, el alumno elabora aplicaciones que permitan el uso del
servicio basado en localización utilizando Google Maps.
TEMARIO
5.1 Tema 10: Manejo de fragments (4 horas)

5.1.1 Que es Fragment
5.1.2 Creating a Fragment, administrar Fragments,Flagment class
5.1.3 Toolbar Fragment Talk to the Activity
5.1.4 Eventos fragment, Aplicación fragment
5.2 Tema 11: Servicios basados en localización (3 horas)

5.2.1 Utilizar Google Maps en la aplicación.
5.2.2 Obtención de la localización (coordenadas) del dispositivo.
5.2.3 Activar las API de Google Maps.

Que es un fragment
Es una porción de la interfaz que puede añadirse y/o quitarser de la interfaz

independientemente de la actividad en curso, un fragmente se puede reutilizar en
varias Activities el propósito principal del fragment es poder diseñar varias
configuraciones de pantalla y que podamos adaptarlo de acuerdo a la necesidad,
adptandose a la horientazión vertical o horizontal con ello reducir el código que
podamos generar. Por ejemplo podemos presentar una aplicación cliente de correo
electrónico, donde al lado izquierdo debemos tener la lista de correos y al lado
derecho mostrar el mensaje de correo, con sus campos clásicos De y Asunto, y por
otro lado debemos mostrar el contenido completo del correo seleccionado. En un
teléfono móvil lo habitual será tener una primera actividad que muestre el listado de
correos, y cuando el usuario seleccione uno de ellos navegar a una nueva actividad
que muestre el contenido de dicho correo. Sin embargo, en un tablet puede existir
espacio suficiente para tener ambas partes de la interfaz en la misma pantalla, por
ejemplo en un tablet en posición horizontal podríamos tener una columna a la
izquierda con el listado de correos y dedicar la zona derecha a mostrar el detalle del
correo seleccionado, todo ello sin tener que cambiar de actividad.
Imagen 51
Fuente: http://jarroba.com/

Ciclo de vida
Al igual que las activity un fragmento tiene un cliclo de vida muy parecido, que el
fragmento depende completamente del activity además de tener características
adcionales que es muy utilizado en tiempo de ejecución para alterralos.
Lista de eventos invocados en el ciclo de vida de un fragment

Evento Descripción / Funcionalidad

onAttach se ejecuta cuando el fragmento ha sido asociado a la actividad
contenedora.
onActiviyCreated Se ejecuta cuando la actividad contenedora ya ha terminado la ejecución de
su método onCreate()
onCreate Se ejecuta cuando el fragmento se está creando. En el puedes inicializar
todos los componentes que deseas guardar si el fragmento fue pausado o
detenido.
onCreateView Se llama cuando el fragmento será dibujado por primera vez en la interfaz
de usuario. En este método crearemos el view que representa al fragmento
para retornarlo hacia la actividad.
onStart Se invoca cuando el fragmento esta visible ante el usuario. Obviamente
depende del método onStart() de la actividad para saber si la actividad se
está mostrando.
onResume Es ejecutado cuando el fragmento esta activo e interactuando con el
usuario. Esta situación depende de la que actividad anfitriona este primero
en su estado Resumed.
onStop Se ejecuta cuando un fragmento ya no es visible para el usuario debido a
que la actividad anfitriona está detenida o porque dentro de la actividad se
está gestionando una operación de fragmentos.
onPause Al igual que las actividades, onPause se ejecuta cuando se detecta que el
usuario dirigió el foco por fuera del fragmento.
onDestroyView Este método es llamado cuando la jerarquía de views a la cual ha sido

asociado el fragmento ha sido destruida.
onDetach Se ejecuta cuando el fragmento ya no está asociado a la actividad anfitriona
La API de los fragmentos se incluyen en el API de Android y se encuentra en la clase

Fragment, por ello cada vez que necesite utilizar se debe extender la clase Fragment en
nuestra nueva clase para heredar su propiedades y comportamientos.
Tambien existen otros librería que se pueden utilizar como

 ListFragment
 DialogFragment
 PreferenceFragment

Código de ejemplo:
public static class FragmentoDemo extends Fragment {

@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container,
Bundle savedInstanceState) {
// Inflate the layout for this fragment
return inflater.inflate(R.layout.fragmento_Demo, container, false);
}
}
El evento onCreateView() recibe como parámetro un objeto de tipo LayoutInflater, el cual

es proveído por la clase anfitriona.
Esta clase es la encargada de inflar el código Java a través del método inflate(). Este
recibe como parámetros el recurso xml del layout, el contenedor(en este caso el view
de la actividad anfitriona) donde será insertado y una bandera indicando si el view que se
producirá debe incorporarse al contenedor.
Como se ve, hemos usado al archivo fragmento_Demo.xml como recurso, el

parámetro container que apunta a la actividad anfitriona y false para indicar que no
indicar que no deseamos comprometer el view del fragmento.
Añadiendo un fragmento a la actividad
Una vez creada la clase y el layout que representa nuestro fragmento debemos añadirlo a
la actividad. Existen dos formas para realizar este proceso.
La primera es a través del archivo layout de la actividad. Donde incluiremos un

componente XML de equivalencia para fragmentos llamado <Fragment>, el cual
referenciará a la clase especifica extendida del fragmento para crear la jerarquía.
Veamos un ejemplo:
Creación del primer layout Fragment
El siguiente paso es crear la interfaz de usuario para el primer fragmento que se

utilizará dentro de nuestra actividad.
Esta interfaz de usuario tiene que estar en un archivo XML, para ello debes estar en la
vista app ira la carpeta es y layout nuevo y lyout resource file como se muestra en el
siguiente grafico

Adición de un archivo de recursos de diseño para un proyecto Android Estudio
En el siguiente cuadro de diálogo resultante, nombre el toolbar_fragment diseño y

cambiar el elemento raíz de LinearLayout a RelativeLayout antes de hacer clic en
Aceptar para crear el nuevo archivo de recursos.
El código fuente inicial es el siguiente:
Sin embargo se debe modificar el XML como se muestra a continuación
<?xml version="1.0" encoding="utf-8"?>

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent" android:layout_height="match_parent">
<Button
android:id="@+id/btnBuscar"

android:text="Buscar"
android:layout_below="@+id/skbBarraBusqueda"
android:layout_alignStart="@+id/edtBuscar" />
<EditText
android:id="@+id/edtBuscar"
android:layout_alignParentTop="true"
android:layout_centerHorizontal="true"
android:layout_marginTop="16dp"
android:ems="10"
android:inputType="text" >
<requestFocus />
</EditText>
<SeekBar
android:id="@+id/skbBarraBusqueda"
android:layout_alignParentLeft="true"
android:layout_below="@+id/edtBuscar"
android:layout_marginTop="14dp" />
</RelativeLayout>
El diseño queda como se muestra:

Creación de la Primera Clase Fragmento
Además de un diseño de interfaz de usuario, un fragmento también tiene que tener

una clase asociada con él para hacer el trabajo real por medio de código. Por ello se
debe adicionar una nueva clase ir a a los archivos de proyecto desplegado en la
carpeta java Añadir una clase para este fin al proyecto desplegando la aplicación
carpeta java bajo el proyecto FragmentExample en la ventana de herramientas del
proyecto y hacer clic derecho sobre el nombre del paquete dado al proyecto cuando se
creó (en este caso com.appmovil. fragmentexample). En el menú que aparece,
seleccione la nueva opción -> Java Class. En el cuadro de diálogo Crear nueva clase
resultando, nombre el ToolbarFragment clase y haga clic en Aceptar para crear la
nueva clase.
Una vez que la clase se ha creado, se debe, por defecto, aparecerá en el panel de
edición en el que se lea como sigue:
package com.appmovil.fragmentexample;
public class ToolbarFragment {

}
Posteriomente se debe agrgar las importaciones necesarias para que el buen

funcionamiento de la aplicación
Por el momento, los únicos cambios en esta clase son para añadir algunas directivas
de importación y reemplazar el método onCreateView () para asegurarse de que el
archivo de diseño se infla y se visualiza cuando se utiliza el fragmento dentro de una
actividad. La declaración de la clase también debe indicar que la clase amplía la clase
Fragmento Android:
package com.appmovil.fragmentexample;
import android.os.Bundle;
import android.support.v4.app.Fragment;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
public class ToolbarFragment extends Fragment {
@Override
public view onCreateView (LayoutInflater inflado,
Contenedor ViewGroup, Bulto
savedInstanceState) {
// Inflar el diseño de este fragmento

Ver view = inflater.inflate (R.layout.toolbar_fragment,

contenedor, false);
vista regresar;
}
}

Servicios basados en localización

Localización Geográfica Básica
La geolocalización es la La localización geográfica en Android existen multitud de
formas de obtener la localización de un dispositivo móvil, la más conocida y popular es
la localización por GPS, también es posible obtener la posición de un dispositivo por
las antenas de telefonía móvil o mediante puntos de acceso Wi-Fi cercanos, y todos
cada uno de estos mecanismos tiene una precisión, velocidad y consumo de recursos
distinto.
A location-based service (LBS)

es un sistema de difusión de información que se puede acceder por los dispositivos
móviles a través de la red móvil. Es impulsado por la capacidad del sistema para
detectar la posición geográfica del dispositivo móvil.
Código de ejemplo: Listar todos los proveedores.
LocationManager locManager =
(LocationManager)getSystemService(LOCATION_SERVICE);
List<String> listaProviders = locManager.getAllProviders();
Clases para localización por GPS
Address
 Una clase que representa una dirección, es decir , un conjunto de cadenas que
describen una ubicación.
Criteria
 Una clase con indicación de los criterios de aplicación para la selección de un
proveedor de ubicación.
Geocoder
 Una clase para el manejo de la geocodificación.
GpsSatellite
 Esta clase representa el estado actual de un satélite GPS.
GpsStatus
 Esta clase representa el estado actual del motor GPS.
Location

 Una clase representa una situación geográfica sintió en un momento

determinado (un "arreglar").
LocationManager
 Esta clase proporciona acceso a los servicios de localización del sistema.
LocationProvider
 Unos proveedores de localización super cclase abstracto.
GpsStatus.Listener
 Se utiliza para recibir notificaciones cuando el estado del GPS ha cambiado.
GpsStatus.NmeaListener
 Se utiliza para recibir sentencias NMEA del GPS.
LocationListener
 Se utiliza para recibir notificaciones de la LocationManager cuando la ubicación
ha cambiado.
Para más detalles visitar el portal de desarrollador google:

http://developer.android.com/guide/topics/location/strategies.html

Google Maps
Google Maps es un servidor de aplicaciones de mapas en la web que pertenece a
Google. Ofrece imágenes de mapas desplazables, así como fotografías por satélite del
mundo e incluso la ruta entre diferentes ubicaciones o imágenes a pie de calle Google
Street View. Desde el 6 de octubre de 2005, Google Maps es parte de Google Local.
Existe una variante a nivel entorno de escritorio llamada Google Earth que ofrece
Google también de forma gratuita. En 2014, los documentos filtrados por Edward
Snowden revelaron que Google Maps es parte y víctima del entramado de vigilancia
mundial operado por varias agencias de inteligencia occidentales y empresas
tecnológicas.
Imagen 215
Fuente: http://www.elandroidelibre.com/wp-content/uploads/2011/05/google-maps-navigation.jpg
Nuevo Google Maps

En la Google I/O 2013, Google presentó un rediseño de Google Maps para la versión
Web, mostrando nuevas funciones como:
 El mapa ocupa toda la pantalla.
 La barra de búsqueda esta en la parte superior izquierda y puede mostrar
información sobre la ubicación.
 En la esquina inferior derecha están ubicados los controles de zoom.
 Ahora hay un modo tierra el cual es una combinación entre la vista satélite y
google earth, en donde podremos ver las ciudades en 3D y al alejar la imagen
podremos ver la Tierra en 3D.
 Al hacer clic en un lugar, nos muestra las reseñas, fotos, números de teléfono y
ver el edificio en Street View.
 Al usar indicaciones podremos ver varias rutas y cambiarlas, además de que se
podrán ver las rutas en avión y reservar vuelos.

Habilitar APIS de google Maps

Google esta compuesto por mucas aplicaciones las cuales las denomina google apps,
Google Apps for Work es un servicio de
Google que proporciona varios productos
de Google con un nombre de dominio
personalizado por el cliente. Cuenta con
varias aplicaciones web con funciones
similares a las suites ofimáticas
tradicionales, incluyendo Gmail, Hangouts,
Calendar, Drive, Docs, Sheets, Slides,
Groups, News, Play, Sites y Vault. Fue la
creación de Rajen Sheth, un empleado de
Google que posteriormente desarrolló las
Chromebooks. 1
Para habilitar las apis de google Maps se debe ingresar a la siguiente dirección:
1. Ingresar a tu cuenta de Gmail

2. Ingresar a la consola de APIS
 https://code.google.com/apis/console
3. Crear un proyecto asociado a la plataforma de desarrollo para nuestro caso es
una aplicación movil en android
4. Habilitar las API necesarias
Instalar google play services

Para utilizar google Maps se debe instalar google play services ingresando al
administrador de librerías como se muestra.
1
Cfr: http://es.wikipedia.org/wiki/Google_Apps

Creando nuestra primera aplicación en google Maps
Datos del proyecto
Se debe modificar el XMl como se muestra en la siguiente imagen
Modificar el glandle como se muestra para agregar las referencias a google play
services
Posterior a ello se debe crear las llaves digitales para firmar la aplicación con los
siguientes comandos como se indica:
keytool -list -v -keystore mystore.keystore

Configurar el archivo de manifiesto como se indica
<meta-data android:name="com.google.android.gms.version"
android:value="@integer/google_play_services_version" />
<meta-data
android:name="com.google.android.maps.v2.API_KEY"
android:value="AIzaSyB9oARLFPe4wRGyeuWJq0IqZ0g84TjmjVI" />
<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"/>
<uses-permission
android:name="com.google.android.providers.gsf.permission.READ_GSERVICES" />
<uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
Agregar el siguiente código para hacer uso de google Maps
import com.google.android.gms.maps.*;
public class MainActivity extends Activity {
private void createMapView(){
try {
if(null == googleMap){
googleMap = ((MapFragment)
getFragmentManager().findFragmentById(
R.id.mapView)).getMap();
if(null == googleMap) {
Toast.makeText(getApplicationContext(),
"Error creating map",Toast.LENGTH_SHORT).show();
}
}
} catch (NullPointerException exception){
Log.e("mapasApp", exception.toString());
}
}
Para agregar marcadores se debe realizar con el siguiente código
import com.google.android.gms.maps.model.LatLng;
import com.google.android.gms.maps.model.MarkerOptions;
Agregar el siguiente método para fijar un marcador

private void addMarker(){
if(null != googleMap){
googleMap.addMarker(new MarkerOptions()
.position(new LatLng(0, 0))
.title("Marker")
.draggable(true)
);
}
}
Finalmente el método oncreate queda como se muestra:

@Override
protected void onCreate(Bundle savedInstanceState) {
setContentView(R.layout.activity_main);
createMapView();
addMarker();
}
Finalmente ejecutando la aplicación se muestra el mapa en el celular como se muestra

UNIDAD
6
Servicios
Al término de la unidad, el alumno elabora aplicaciones desatendidas basadas
en servicios que permitan realizar operaciones como descarga de archivos
grandes, monitorear usuarios basado en geolocalización.
TEMARIO
6.1 Tema 13: Creando y administrando Servicios (4 horas)

6.1.1 Qué es un servicio,
6.1.2 Anatomía de un servicio, accesos y permisos.
6.1.3 Intent Service, Bound Service.
6.1.4 Configurar el archivo de manifiesto.
6.1.5 Iniciar/Configurar servicios

Que es un servicio (Service)
Los servicios son componentes sin interfaz gráfica que se ejecutan en segundo plano.
En concepto, son exactamente iguales a los servicios presentes en cualquier otro
sistema operativo como por ejemplo Windows los servicios de Windows update, o el
servicio de actualización de la hora de windows. Los servicios pueden realizar
cualquier tipo de acciones, por ejemplo actualizar datos, lanzar notificaciones, o
incluso mostrar elementos visuales como por ejemplo Activities si se necesita en algún
momento la interacción con del usuario. La plataforma de Android tiene una gran
variedad de servicios que ofrece como por ejemplo los alertas cuando la batería esta
baja o por ejemplo cuando llega un mensae de texto o alertas para aceder a dichos
servicios se puede realizar con la clase Manager. De esta manera, en nuestras
actividades podremos accesar a estos servicios a través del
método getSystemService().
Por otro lado, si necesitamos utilizar servicios propios, estos deben ir declarados
en el archivo AndroidManifest.xml.
Imagen: Ciclo de vida de los servicios

Fuente: http://cd1.faqsandroid.com/wp-content/uploads/2012/08/service_lifecycle.jpg

Creando un servicio de musica
1. Crea un nuevo proyecto con los siguientes datos:
2. Reemplaza el código del layout activity_main.xml por:
<LinearLayout
android:layout_height="fill_parent">
<TextView android:layout_width="fill_parent"
android:text="Servicio de reproducción de música"/>
<Button android:id="@+id/boton_arrancar"
android:text="Arrancar servicio"/>
<Button android:id="@+id/boton_detener"

android:text="Detener servicio"/>
</LinearLayout>
El diseño de pantalla queda Como se muestra
3. Agregar la clase ServicioMusica
3.1. Agregar el siguiente código en el activity main:

4. agregar el siguiente código en el servicio de musica:
package solucionesmoviles.serviciomusica;
import android.app.Service;
import android.content.Intent;
import android.media.MediaPlayer;
import android.os.IBinder;
import android.widget.Toast;
/**
* Created by peextssolis on 06/03/2015.
*/
public class ServicioMusica extends Service {
MediaPlayer reproductorMusica;
@Override
public void onCreate() {
Toast.makeText(this, "Servicio iniciado",
Toast.LENGTH_SHORT).show();
reproductorMusica = MediaPlayer.create(this, R.raw.audio);
}
@Override
public int onStartCommand(Intent intenc, int flags, int idArranque) {
Toast.makeText(this,"Servicio arrancado "+ idArranque,
reproductorMusica.start();
return START_STICKY;
}
@Override
public void onDestroy() {
Toast.makeText(this,"Servicio detenido",
reproductorMusica.stop();
}
@Override
public IBinder onBind(Intent intencion) {
return null;
}
}
5. Modificar el archivo de manifiesto AndroidManifest.xml y agregar el siguiente

código de declaración de servicio en el tag <application>.
<service android:name=".ServicioMusica" />

6. Ahora debes crear una nueva carpeta con nombre raw dentro de la carpeta res.
Arrastra a su interior el ficheroaudio.mp3.
7. Ejecuta la aplicación y comprueba su funcionamiento. Puedes terminar la

actividad pulsando el botón de retroceder y verificar que el servicio continúa en
marcha.

UNIDAD
7
Multimedia y publicación
Al término de la unidad, el alumno elabora aplicaciones que permitan el uso del
video y de sus dispositivos visuales y las publicará en GooglePlay.
TEMARIO
7.1 Tema 12: Audio, Video y Uso de Dispositivos visuales

7.1.1 Componente Media Player. Definición, características y aplicaciones.
7.1.2 Visualización de videos usando la vista Video.
7.1.3 Grabación de audio y video: Uso de Intents para grabar video.
17.2 Tema 14: Publicación en Google Play

7.2.1 Generación de APK firmado con el certificado digital.
7.2.2 Creación de la cuenta en Google Play.
7.2.3 Publicación de la aplicación

Audio, Video y Uso de Dispositivos visuales
Multimedia
La capacidad de reproducir contenido multimedia es una característica presente en la

práctica totalidad de las terminales telefónicas existentes en el mercado hoy en día.
Muchos usuarios prefieren utilizar las capacidades multimedia de su teléfono, en lugar
de tener que depender de otro dispositivo adicional para ello. Android incorpora la
posibilidad de reproducir no sólo audio en diversos formatos, sino que también vídeo.
Los formatos de audio soportados son los siguientes:
 AAC LC/LTP
 HE-AACv1 (AAC+)
 HE-AACv2 (Enhanced ACC+)
 AMR-NB
 AMR-WB
 FLAC
 MP3
 MIDI
 Ogg Vorbis
 PCM/Wave
Con respecto al vídeo, los formatos soportados son:

 H.263
 H.264 AVC
 MPEG-4 SP
 VP8
En esta sesión echaremos un vistazo a las herramientas necesarias para poder

reproducir contenido multimedia (audio o vídeo) en una actividad. También veremos
cómo añadir la capacidad a nuestra aplicación para la toma de fotografías, una
característica perfectamente emulada por el emulador en las últimas versiones del
Android SDK.

Reproducción de audio
La reproducción de contenido multimedia se lleva a cabo por medio de la clase
MediaPlayer. Dicha clase nos permite la reproducción de archivos multimedia
almacenados como recursos de la aplicación, en ficheros locales, en proveedores de
contenido, o servidos por medio de streaming a partir de una URL. En todos los casos,
como desarrolladores, la clase MediaPlayer nos permitirá abstraernos del formato así
como del origen del fichero a reproducir. Incluir un fichero de audio en los recursos de
la aplicación para poder ser reproducido durante su ejecución es muy sencillo.
Simplemente creamos una carpeta raw dentro de la carpeta res, y almacenamos en
ella sin comprimir el fichero o ficheros que deseamos reproducir. A partir de ese
momento el fichero se identificará dentro del código como R.raw.nombre_Archivo.
Para reproducir un fichero de audio tendremos que seguir una secuencia de pasos.
 En primer lugar deberemos crear una instancia de la clase MediaPlayer.

 El siguiente paso será indicar qué fichero será el que se reproducirá. Por último
ya podremos llevar a cabo la reproducción en sí misma del contenido
multimedia.
Veamos primero cómo inicializar la reproducción.
Tenemos dos opciones. La primera de ellas consiste en crear una instancia de la clase
MediaPlayer por medio del método create(). En este caso se deberá pasar como
parámetro, además del contexto de la aplicación, el identificador del recurso, tal como
se puede ver en el siguiente ejemplo:
Reproducción de vídeo usando el control VideoView
La reproducción de vídeo es muy similar a la reproducción de audio, salvo dos

particularidades. En primer lugar, no es posible reproducir un clip de vídeo
almacenado como parte de los recursos de la aplicación. En este caso deberemos
utilizar cualquiera de los otros tres medios (ficheros locales, streaming o proveedores
de contenidos). Un poco más adelante veremos cómo añadir un clip de vídeo a la
tarjeta de memoria de nuestro terminal emulado desde la propia interfaz de Eclipse. En
segundo lugar, el vídeo necesitará de una superficie para poder reproducirse. Esta
superficie se corresponderá con una vista dentro del layout de la actividad. Existen
varias alternativas para la reproducción de vídeo, teniendo en cuenta lo que acabamos
de comentar. La más sencilla es hacer uso de un control de tipo VideoView, que
encapsula tanto la creación de una superficie en la que reproducir el vídeo como el
control del mismo mediante una instancia de la clase MediaPlayer. Este método será
el que veamos en primer lugar. El primer paso consistirá en añadir el control
VideoView a la interfaz gráfica de la actividad en la que queramos que se reproduzca
el vídeo. Podemos añadir algo como lo siguiente el fichero de layout correspondiente:

Dentro del código Java podremos acceder a dicho elemento de la manera habitual, es decir,
mediante el método findViewById(). Una vez hecho esto, asignaremos una fuente que se
corresponderá con el contenido multimedia a reproducir. El control VideoView se encargará de
la inicialización del objeto MediaPlayer. Para asignar un video a reproducir podemos utilizar
cualquiera de estos dos métodos:
Una vez inicializado el control se puede controlar la reproducción con los métodos:
 start()
 stopPlayback()
 pause()
 seekTo()
La clase VideoView también incorpora el método setKeepScreenOn(boolean)con la que se

podrá controlar el comportamiento de la iluminación de la pantalla durante la reproducción del
clip de vídeo. Si se pasa como parámetro el valor true ésta permanecerá constantemente
iluminada.
El siguiente código muestra un ejemplo de asignación de un vídeo a un control VideoView y de

su posterior reproducción. Dicho código puede ser utilizado a modo de esqueleto en nuestra
propia actividad. También podemos ver un ejemplo de uso de seekTo(), en este caso para
avanzar hasta la posición intermedia del video.
En esta sección veremos en último lugar, tal como se ha indicado anteriormente, la manera de
añadir archivos a la tarjeta de memoria de nuestro dispositivo virtual, de tal forma que podamos
almacenar clips de vídeo y resolver los ejercicios propuestos para la sesión. Se deben seguir
los siguientes pasos:
En primer lugar el emulador debe encontrarse en funcionamiento, y por supuesto, el dispositivo
emulado debe hacer uso de una tarjeta SD.

Gráficos 2D y Aplicaciones Multimedia

Las librerías android.graphics.drawable y android.view.animation son proporcionadas por
Android para dibujar y animar imágenes y formas 2D.
Drawables
Se refiere a todo aquello que se puede dibujar. Es la clase de la cual heredan una variedad de
tipos de gráficos, incluyendo BitmapDrawable, ShapeDrawable, PictureDrawable,
LayerDrawable y otros. Hay tres maneras distintas de instanciar una clase Drawable.
 Utilizar una imagen almacenada en el directorio de recursos de nuestro proyecto.
 Utilizar un XML que define las propiedades del objeto para luego poder
recuperarlo mediante getDrawable() y el ID que se le asignó en el XML.
o Utilizando los constructores propios de la clase.
 Lxas librerías android.graphics.drawable y android.view.animation son proporcionadas por
Android para dibujar y animar imágenes y formas 2D.
ShapeDrawable
Se utiliza para realizar realizar gráficos simples en 2D y aplicarles estilos directamente
Desde el código de nuestra aplicación.
Al ser una clase que hereda de Drawable, se puede utilizar en el mismo contexto que ésta. Se
pueden realizar por lo tanto clases View que dibujen formas personalizadas gracias al métdo
onDraw() que incluye la clase ShapeDrawable.
Crear un reporductor mediaplayer

Crear una instancia de MediaPlayer y ejecutar el método start() pasando la referencia al
recurso.
MediaPlayer mp= MediaPlayer.create(getApplicationContext (), R.raw.bundle);
mp.start();
Reproducir desde stream

 Crear una instancia de MediaPlayer y usar el método setDataSource()wcon la cadena
que contiene el path al sitema local o la URL.
 Utilizar prepare() y después start()en la instancia.
MediaPlayer mp = new MediaPlayer();

mp.setDataSource( PATH_TO_FILE);
mp.prepare();
mp.start();

Grabar audio y video

Para ello se utiliza la clase MediaRecorder.

Publicación de software
Para publicar nuestras aplicaciones primero tenemos que empaquetarlas. Antes de

empaquetar debemos preparar el código y comprobar que todo esté correcto:
 Nombre de la aplicación, icono y versión.

 Deshabilitar debugging en el AndroidManifest.xml (atributo
android:debuggable="false" del tag de application).
 Eliminar cualquier mensaje de Log.
 Pedir sólo los permisos que de verdad la aplicación use, y no más de los
necesarios. • Por supuesto, haber probado la aplicación en terminales reales, a
ser posible en más de uno.
Antes de comenzar con nuestra publicación debemos aprender como funciona la

herramienta de control de aplicaciones de google denominado “google play”
Google Play Services

Es una aplicación del sistema de Android que nos permitirá tener el resto de
aplicaciones de nuestro terminal siempre actualizadas, ya que se encargará de
comprobar que todas las apps instaladas están en la última versión disponible.
Las funciones principales de Google Play Services son la autentificación de servicios

de Google, la sincronización de contactos, el acceso a la última configuración de
privacidad del usuario, y los servicios basados en la ubicación de mayor calidad y
menor potencia.

Modo de control de licencias por google play
Una vez publicado la aplicación la licencia se valida con la librería de google play
cliente y este se comunica con el servidor de google
Firmar la aplicación android

Para firmar la aplicación debes dar realizar el siguiente procedimiento
Prepara tu APK
 Cuando estés listo para realizar cambios en el APK, asegúrate de actualizar
también el Código de versión de la aplicación para que los usuarios existentes
reciban la actualización.
 Utiliza la siguiente lista de verificación para asegurarte de que el nuevo APK

esté listo para actualizar a los usuarios existentes:
 El nombre de paquete del archivo APK actualizado debe ser el mismo que el
de la versión actual.
 El código de versión debe ser superior al código de la versión actual. Obtén

más información sobre cómo crear versiones de tu aplicación.
La firma del archivo APK actualizado debe coincidir con la firma de la versión actual.
Para comprobar que el archivo APK utiliza la misma certificación que la versión
anterior, puedes ejecutar el siguiente comando en ambos archivos APK y comparar los
resultados:
$ keytool -genkey -v -keystore nombredenuestrakeystore.keystore

-alias aliasdenuestrakeystore -keyalg RSA -keysize 2048 -validity 10000
Si los resultados son idénticos, significa que estás utilizando la misma clave y que
puedes continuar. Si los resultados son diferentes, tendrás que volver a firmar el
archivo APK con la clave correcta.

Publicar Aplicaciones
1. Ingresar a tu cuenta de Gmail
2. Ingresar a la consola de publicaciones de google play
 https://play.google.com/apps/publish/
1. Agregar un nombre
2. Dar click en Preparar Ficha de play store
 https://play.google.com/apps/publish/
3. Ubicar clave de API pública

VII. BIBLIOGRAFÍA DEL CURSO
Básica
GIRONÉS, Jesús Tomas

2013 El gran libro de Android 3era Edición.
México: Alfa y Omega.
GARGENTA, Marko
2011 Learning Android (245 pages)
United States of America: O’Reilly Media, Inc.
HODSON, Ryan
2014 Android Programming Succinctle.
United States of America: Syncfusion Inc.
THOMAS, Erl
2010 Service Oriented Architecture: A field Guide to integrating XML and Web
Services.
United States of America Canada: Prentice Hall
SMYTH, Neil
2014 Android 4.4 App Development Essentials (47 pages). Lean Publishing
Bibliografía Electrónica
SATYA, Komatineni y MACLEAN, Dave

2012 Expert Android. (Consulta: 22 de enero 2015)
United States of America: Apress Inc.
Recuperado de:
http://androidbook.com/akc/display?url=ShowAttachmentsIMPURL&reportId=442
3&downerUserId=satya&order_by_format=name
ANDROID Developer
2014 Sitio web oficial de desarrollo Android. (Consulta: 27 de Diciembre
2014)(http://developer.android.com/index.html)
LÓPEZ, Victoria
2010 Introducción a Android (117 páginas). (Consulta: 25 de enero 2015)
España: Grupo Tecnología CM (Universidad Complutense de Madrid)
Recuperado de:
http://pendientedemigracion.ucm.es/info/tecnomovil/documentos/android.pdf
Complementaría
MENG LEE, Wei

2013 Android Application Development Cookbook (385 pages).
Indianápolis, Indiana EEUU: John Wiley & Sons, Inc.
MENG LEE, Wei

2012 Beginning Android™ 4 Application Development.
United States of America: John Wiley & Sons, Inc.
APRESS AND Commonsware

2010 Beginning Android 4.

United States of America: Apress Inc.
GARGENTA, Marco
2011 Learning Android Building applications for be Android Market.
United States of America: O’Reilly Media, Inc
RETO, Meir RETO (2012).

2012 Android™ 4 Application Development.
United States of America - Indianapolis, Indiana: John Wiley & Sons, Inc.

Manual 2015-I 05 - Desarrollo de Aplicaciones Móviles I (1896)

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Manual 2015-I 05 - Desarrollo de Aplicaciones Móviles I (1896)

Transféré par

Droits d'auteur :

Formats disponibles

DESARROLLO DE

CARRERAS PROFESIONALES CIBERTEC

1.2 IDE Android Studio 18

UNIDAD 2. ANDROID: COMPONENTES 32

2.2 Componente de una pantalla: Views y ViewGroups 44

2.3 Componente Activity e Intent: definición y características 56

2.4 Orientación del dispositivo 66

2.5 Dialogos y notificaciones 69

UNIDAD 3. PERSISTENCIA DE DATOS EN ANDROID 84

3.2 Persistencia de Datos usando SQLite

CIBERTEC CARRERA DE ELECTRICIDAD

3.2.2 Introducción a SQLite 96

3.3 Aplicando el Modelo Vista controlador con SQLite

UNIDAD 4. NETWORKING EN ANDROID

UNIDAD 5. Servicios basados en localización

5.1 Servicios basados en localización

UNIDAD 7. MULTIMEDIA Y PUBLICACIÓN

7.1 Publicación en Google Play

Bibliografia del curso 159

CARRERAS PROFESIONALES CIBERTEC

El manual para el curso ha sido diseñado bajo la modalidad de unidades de

El curso es práctico y consiste en un taller de programación. En la primera parte

CIBERTEC CARRERA DE ELECTRICIDAD

CARRERAS PROFESIONALES CIBERTEC

DESARROLLO DE APLICACIONES MÓVILES I

Unidad 1 Unidad 2 Unidad 3 Unidad 4 Unidad 5 Unidad 6 Unidad 7

Android: Android: Networking en Servicios basados Multimedia y

CIBERTEC CARRERA DE ELECTRICIDAD

CARRERAS PROFESIONALES CIBERTEC

1.3 Plataforma Android

1.4 IDE Android Studio

 Los alumnos identifican la arquitectura del sistema operativo android.

CIBERTEC CARRERA DE ELECTRICIDAD

CARRERAS PROFESIONALES CIBERTEC

1.1. INTRODUCCIÓN A LA PLATAFORMA

La desición de estudia el desarrollo de aplicaciones

Figura 2: Dispositivos que soportan Android

CIBERTEC CARRERA DE ELECTRICIDAD

Figura 3: Dispositivos que soportan Android

Qué es una Aplicación Android?

Figura 4: Programas posibles para instalar en el celular

CARRERAS PROFESIONALES CIBERTEC

1.1.2 Características y Arquitectura Android

El sistema operativo Android, al igual que los propios teléfonos móviles, ha

Entre las principales características tenemos:

 framework de aplicación que habilita la reutilización y reemplazo de

 máquina virtual dalvik optimizada para móviles

 navegador integrado basado en webkit

 gráficos optimizados por una librería gráfica 2d propia; gráficos 3d

 sqlite para almacenamiento de datos estructurados

CIBERTEC CARRERA DE ELECTRICIDAD

Cupcake: Android Version 1.5

Donut: Android Version 1.6 Características: Añade a la anterior la mejoría de

Eclair: Android Version 2.0/2.1

Froyo: Android Version 2.2

Ginger Bread: Android Version 2.3

Honey Comb: Android Version 3.0/3.4

Ice Cream Sandwich: Android Version 4.0

Android - 4.4 KitKat

Android - 5.0 Lollipop

CARRERAS PROFESIONALES CIBERTEC

1.1.3 Máquina virtual Dalvik Virtual Machine y ART

Dalvik Vrtual Machine

Figura 7: Arquitectura de android