Desarrollo de Aplicaciones Móviles

SERVICIO NACIONAL DE ADIESTRAMIENTO EN TRABAJO INDUSTRIAL
DESARROLLO
DE SOFTWARE
MANUAL DE APRENDIZAJE
DESARROLLO DE
APLICACIONES MÓVILES
CÓDIGO: 89001737
Profesional Técnico
DESARROLLO DE APLICACIONES MÓVILES
CONTENIDO Nº PAG
I. INTRODUCCIÓN A ANDROID. 5
II. INSTALACIÓN Y CONFIGURACIÓN DE ECLIPSE. 18
III. ENTORNO DE DESARROLLO – ANDROID - GUI. 34
IV. CREACIÓN DE UNA APLICACIÓN ANDROID. 40
V. CONFIGURACIÓN Y PROGRAMACIÓN DE CONTROLES
44
BÁSICOS.
VI. CAPTURANDO Y MANEJANDO EVENTOS DE USUARIO. 63
VII. INTENTS E INTENS FILTERS. 72
VIII. ANIMACIÓN Y DISEÑO DE MENUS. 76
IX. GEOLOCALIZACIÓN Y MAPAS. 80
X. ALMACENAMIENTO Y RECUPERACIÓN DE DATOS - SQLITE. 82
XI. SERVICIOS DE RED. 113
XII. SERVICIOS WEB ANDROID CON PHP. 118
ESCUELA DE TECNOLOGÍAS DE LA INFORMACIÓN 4

I. INTRODUCCIÓN A ANDROID.
OPERACIONES:
- Conocer el Sistema Operativo Android.
- Identificar las diferencias entre versiones de Android.
EQUIPOS Y MATERIALES:
- Computadora con microprocesador i3 o superior.
- Sistema operativo Windows.
QUÉ ES ANDROID.
El sistema operativo Android es un sistema basado en muchas de las
características que tiene linux este sistema operativo tiene basado su núcleo
en Linux. Android fue diseñado en sus inicios principalmente para todos los
dispositivos móviles como Tablets y Smartphone pero en la actualidad este
sistema operativo ha tomado gran poder en la tecnología siendo utilizado no
solo para móviles sino también para cualquier tipo de dispositivo electrónico
como lo puede ser un reloj, un televisor, una radio, un autorradio, una lavadora,
un microondas, etc.
Android fue lanzado en el año 2007 junto a la fundación del Open Handset
Alliance (unión de las mejores empresas del mundo que lideran el mercado de
tecnologías en general) la cual le ayuda en avanzar para sus estándares de
desarrollo.
En la actualidad los móviles con sistemas operativos Android venden y se

distribuyen más que sus mejores competidores como lo son iOS o
WindowsPhone.
El éxito de este gran sistema operativo se puede basar en la gran cantidad de

aliados tecnológicos y en la libertad de utilizar su código ya que hacen de
Android en mejor sistema operativo para ser usado.
El 25 de junio de 2014 la empresa Google mostró un producto más

evolucionado con la finalidad de unificar el hardware y el software y llegar así a
ganar más terreno en el mercado. Esa fecha Android mostro otros productos
como fueron televisores, autorradios, entre otros con el nombre de Android
One.

HISTORIA DE ANDROID.
El creador del S.O. Android fue el ingeniero de telecomunicaciones Andy Rubin

quien termino su licenciatura en Ciencias de la Computación en la Universidad
de Utica, en Nueva York, E.E.U.U..
Uno de los primeros trabajos importantes que tuvo Andy Rubin fue de trabajar
como ingeniero de la gran empresa Apple, es ahí donde comenzó con los
proyectos para móviles, de la empresa Apple surgió una empresa llamada
General Magic y es con esta empresa donde comenzó con el desarrollo de un
proyecto llamado Magic Cup lo que en ese entonces sería un sistema operativo
móvil, sin embargo los teléfonos de esas épocas no tenían la suficiente
tecnología como para que puedan ser instalado un S.O. con las características
de un S.O. Inteligente por lo tanto el proyecto tuvo que ser cerrado.
Luego Andy se unió a Artemis Research, una empresa que también tenía miras
a creas un sistema operativo para móviles inteligentes, pero esta empresa
termino comprada por Microsoft desplazando una vez más a Andy Rubin a la
quiebra.
Hasta el momento ya teníamos a Andy Rubin trabajando para Apple y

Microsoft, curiosamente sus más fuertes competidores en la actualidad.
Después de 2 fracasos Andy rubin decisión fundar su propia empresa llamada

Danger Inc. En donde suceden cosas muy importantes.
Una de las primeras cosas que se desarrolla en Danger es primer teléfono

inteligente de la época, fue el primer Smartphone con tecnología inteligente,
pero aun así no tuvo mucha acogida, lo que llevo a la empresa Danger a ser
cerrada.
Luego en el 2003 Andy Rubin formo otra empresa llamada Android Inc., en esa
época y después de tanta experiencia en telefonía móvil formo una empresa
con la tecnología necesaria para crear los modernos y potentes sistemas
operativos con los que nos vemos conectados hoy en día.
En Agosto de 2005, Google adquirió la empresa, pero al momento de adquirirlo

el paso a formar parte del equipo de desarrollo de proyectos móviles ocupando
el puesto vicepresidente de ingeniería de Google encargándose de todo el
proyecto Android.

Durante 16 años android fue madurando en la cabeza de Andy ya que toda su

vda profesional la dedico a investigar y desarrollar soluciones para móviles por
lo tanto cuando Andy llego a google pues tenia un gran potencial el cual era la
experiencia de tantos años.
Pero después de que Andy ingresara a la empresa y trabajara unos años

dentro de Google fue el 5 de Noviembre de 2007 que Google anuncio el
lanzamiento oficial del sistema operativo Android , pero durante todos esos
años Andy Rubin aparte de desarrollar todo el sistema Operativo, busca
alianzas estratégicas con las grandes empresas que lideran el mercado como
lo son Sansung, Hp, Intel, Lg, entre otras fundando la alianza más grande de
empresas la cual se le conoce como LA OPEN HANSET ALLIANCE
LA OPEN HANDSET ALLIANCE.
La Open Handset Alliance se le llama a toda la agrupación de mas de 100

empresas lideres en el mercado tecnológico y que se han unido para hacer que
los consumidores finales, es decir los clientes que compran productos para su
uso personal tengan de una de las mejores tecnologías del mercado con un
precio econocmico.
Cada uno de los integrantes de la Open Handset Alliance está muy

comprometido en hacer grande la apertura de sus productos utilizando el gran
sistema operativo Android. El estar unidos hará que todos puedan innivar sus
productos de una manera más rápida que si estuvieran separados, esto sería
una muy buena ventaja en favor del consumidor.
Miembros de la Open Handset Alliance.

Como se ha mencionado la Open Handset Alliance está formada por las más
grandes empresas del mercado las cuales son líderes en cada una de sus
productos. A continuación algunas de las empresas que en la actualidad
forman parte de la Open Handset Alliance.

Un S.O Móvil es un sistema que es capaza de controlar un dispositivo móvil

como puede sLer un celular o una Tablet, en la actualidad no solo estamos
hablando de dispositivos como celular o Tablet sino también de cualquier
dispositivo electrónico como lo es un autoradio, un reloj, un sistema de una
lavadora, televisor, radio o algún otro dispositivo electrónico. Hoy en día los
sistemas operativos no son tan simples como lo eran antes, en la actualidad
son capaces de controlar cualquier sistema de algún dispositivo electrónico.
Entre los sistemas operativos más conocidos se tienen:
Android.
Este sistema operativo es aquel que lidera el mercado ya que cuenta con una
gran popularidad en el ámbito móvil, su cuota en el mercado es del 83% y una
de sus principales características es que es un software libre, es decir Open
Source, no tiene una licencia por la cual se tenga que pagar. Este gran sistema
operativo es de Google y está disponible para cualquier creador o fabricante
interesado en utilizar dicho sistema operativo.
Esta disponibilidad fácil del sistema operativo a

ocasiona que se generen innumerables modelos
utilizando los distintos tipos de versiones con las que
cuenta el sistema operativo, pudiendo encontrar gran
variedad de modelos de sistemas operativos, además

de esto cada uno de los fabricantes o personas que utilizan el sistema

operativo pueden crear sus capas adicionales en el sistema ya que es un
código abierto.
Una de las grandes ventajas con las que cuenta Android es la gran cantidad de
aplicaciones gratuitas con las que cuenta el sistemas operativo Android, estas
aplicaciones se encuentran en la tienda virtual y pueden ser descargadas por
cualquier usuarios que cuente con sistema operativo Android.
iOS Su principal característica del sistema

operativos móvil IOS es que a comparación
del sistema operativo Android este es un
software cerrado, es decir nadie puede
acceder a su código, ya que Apple no
quiere que nadie pueda modificar alguna
parte de su código por lo tanto viene a ser
algo limitante para los fabricantes de dispositivos ya que no tienen la libertad
que les ofrece Android para sus dispositivos.
Sin embargo, un sistema operativo cerrado como lo es IOS ofrece una versión
de sistema operativo mucho más estable y seguro ya que cuenta con la
garantía del fabricante que lo creó.
Lo explicado tiene sus ventajas y desventajas ya que para un creador puede

ser algo limitante el uso de dicho sistemas pero para un usuario puede resultar
más seguro y más sólido el uso del sistema cerrado.
Windows Phone
Windows Phone es un sistema operativo el cual
ha ingresado al mercado tiempo después que
sus dos antecesores y líderes en el mercado
como lo son Android y IOS, este sistema
operativo también es un sistema operativo
cerrado y cuenta con poca cuota de usuarios en
el mercado, según estudios de fines del 2014
solo contaba con 3% de la cuota de usuarios del mercado de Smartphones,
Microsoft está haciendo muchos esfuerzos por alcanzar la cima de las ventas y
los usuarios incluso a formado una alianza con la empresa Nokia la cual le ha
permitido hacerse mas conocida ya que los móviles Nokia vienen ya instalados
con este S.O. (según el modelo).

Windows phone cuenta con un diseño totalmente distinto a los dos sistemas
mencionados, este destaca su pantalla de inicio la cual ofrece notificaciones de
las App de una forma más sencilla y mucho más limpia que las dos anteriores.
Si se puede sacar un punto a su favor es que Windows phone cuenta con una
interfaz de usuario muy amigable muy parecido al uso de una pc convencional
con sistema operativo Windows.
Este sistema operativo móvil cuenta con un gran número de App disponibles en
el mercado, aunque no tantas como lo son sus grandes competidores como
Android e iOS, Windows phone cuenta con más de 300 000 App en su tienda
virtual, además ofrece sus propias aplicaciones como los son Skye, OneDrive o
Xbox.
Firefox OS
Firefox OS es un sistema operativo basado en
Tecnología Web con el famoso lenguaje de
programación HTML5, este sistema operativo cuenta con
núcleo Linux y al igual que Android es Open Source es
decir software libre. Este sistema operativo fue
Desarrollado por Mozilla Corporatión con la ayuda y
colaboración de muchas empresas de telefonía móvil.
La gran ventaja que tiene este sistema operativo móvil frente a otros sistemas
operativos es la facilidad de que sus aplicaciones sean usadas por cualquier
proveedor de sistemas operativo móvil ya que cuenta con tecnologías HTML5,
JavaScript y Css esto hace que cumpla con las condiciones que cumple un
navegador pero utilizando los recursos del móvil, permitiendo el uso de las
aplicaciones en cualquier tipo de sistema operativo.
Todas sus aplicaciones requieren de un paquete comprimirdo el cual se

cargara localmente para que la aplicación pueda acceder a la aplicación.
BLACKBERRY
El sistema operativo BlackBerry fue en sus
inicios conocido como RIM el cual es sus
mejores épocas fue uno de los líderes en el
mercado móvil, en la actualidad Blackberry
no pasa por uno de sus mejores momentos
ya que la los sistemas operativos como Android e iOS han tomado posesión del
mercado móvil, desplazando a BlackBerry casi fuera del mercado de móviles.
Acostumbrado a ofrecer terminales con teclado físico, el paso a las pantallas
táctiles no fue uno de sus mejores opciones quedando así desplazado por los

consumidores. Los esfuerzos echos por la empresa BlackBerry para poder

volver a ser líderes en el mercado han sido muy significativas ya que en el año
2012 lanzaron versiones mejoradas a las anteriores, pero ahun asi los estudios
indican que Android e IOs siguen liderando el mercado móvil, teniendo
Blackberry solo el 0,5% de ventas a nivel mundial.
VERSIONES DE ANDROID.
Con el pasar de los años el sistema Operativo Android ha tenido muchas

evoluciones, su primera versión fue lanzada en el año 2008 y fue la versión
Angel Cake 1.0, a partir de ese momento el sistema ha ido evolucionando
agregando más funciones en cada una de sus versiones.
Desde un primer momento Google ha puesto a cada uno de sus versiones

nombres muy familiares y alusivos a una comida o a un dulce, además tiene
una particularidad de que los nombres de las versiones vienen en orden
alfabético (Angel Cake, Battenberg, Cupcake, etc), a continuación mostramos
una descripcion de cada uno de los sistemas Operativos.
Apple Pie (Tarta de Manzana).

- Fue Lanzado al consumidor el 23 Septiembre 2008.
- Esta versión fue la primera, en esta versión no se vio ningún
tipo de mejora.
- Esta versión no se vio comerncialmente, fueron muy pocos
los móviles que la portaron.
Banana Bread (Pan de Banana).

- Fue Lanzado al mercado el 9 Febrero del 2009.
- Esta versión básicamente corrigio errores de la versión
anterior.

- Esta versión tampoco se porto comercialmente, fue versión beta.
Android 1.5 o Cupcake (magdalena).

Fue la primera actualización que tuvo el Sistema Operativo
Android.
En esta versión no se agregaron muchos cambios a la plataforma

pero si se mejoró las transiciones de ventanas, el scroll en el
navegador.
Android 1.6 o Donut.

En esta segunda actualización la interfaz permanece quedo casi
inalterada aunque se rediseñan los iconos y los widgets.
En esta versión también podemos notar un cambio en la interfaz

del uso de la cámara en todos los dispositivos y además notamos
un gran cambio en la tienda virtual ya que cambia la apariencia de
tanto en diseño como en herramientas.
Android 2.0 o Eclair (rollo de crema).

Esta fue una de las versiones más importantes ya que tuvo un
cambio muy significativo en su interfaz y diseño de cada una de
sus pantallas. Su interfaz cambió significativamente con un
diseño mas novedoso haciendo notas sus íconos, aplicaciones
de framework, menus, opciones, entre otros.
Este cambio fue reforzado aún más ya que la gran empresa de móviles
Motorola lanzo una importante campaña de marketing haciendo aún más
conocido los sistemas operativos.
Se observa también que por primera vez se muestran los fondos animados, es
decir imágenes con movimiento para los fondos de las pantallas de los
celulares, est hice ue se vuelva una versión muy atractiva y es mas, hasta el
dia de hoy se pueden observar móviles que tienen ese sistema operativo.
Android 2.2 o Froyo (yogourt helado).

La versión 2.2 conocida como Froyo es una actualización menor y
no muy significativa. Lo que se buscó en esta versión fue trabajar
con el aspecto de imágenes los cuales se les genera una mejor
vista a todas las galerías de fotos, así como algunos widgets que
se crean.

Android 2.3 o Gingerbread (galletas de jengibre).

En esta versión también podemos notar un cambio en la interfaz
gráfica del sistema operativo ya que en esta versión se rediseñan
los menús, colores e iconos del sistema.
Tambien en esta versión tenemos como innovación el teclado, y

además de una mejora muy siginificativa en su uso gracias a la
colocacion de las teclas y el teclado virtual.
En esta versione también notamos un nuevo android market con un mejor

diseño de su interfaz.
Android 3.0 o HoneyComb (panal de abeja).

Todas las versiones anteriores estaban basadas en
pantallas para móviles y aplicaciones con los cuales
contaba un SmartPhone, pero con el pasar de los años las
tablets se convirtieron en un elemento diario y muy
importante en los usuarios, por lo tanto en esta versión se
quiso crear un sistema operativo solo y exclusivo para el
uso de los sistemas operativos para tablets, lo cual con el
pasar del tiempo no tuvo mucha acogida ya que se contaba con dos sistemas
operativos para un mismo fin por lo tanto la versión no duro mucho tiempo en
el mercado.
Android 4.0 o Ice Cream Sandwich (sandwich de helado).

En esta versión lo que se hace es unir las versiones de
Gingerbread y de HoneyComb ya que hasta el momento se
contaba con dos versiones una para celulares y otra para
tablets, como lo dijimos ambas con un mismo fin, por lo
tanto en esta versión se unifican ambas versiones
quedando un solo sistema operativo tanto para celulares
como para tablets.
Además se agregan nuevas funciones en la barra de notificaciones, así como

también aparece la barra inferior de HoneyComb y también se crea una
compatibilidad entre pantallas y entre cualquier tipo de dispositivo móvil que
sea Smartphone o Tablet.
Android 4.1 o Jelly Bean (caramelitos).

En esta versión no podemos oberservar cambios muy
relevantes si es que se habla de diseño de interfaz pero son
sus cambios internos los que se pueden observar, ya que

agregan un nuevo sistema de notificaciones que se encuentran en la misma

zona donde estaban, además se agrega un nuevo sistema de administracion
de datos entre la CPU y la GPU el cual lleva el nombre de Project Butter
haciendo el intercambio de comunicación entre aplicaciones o entre ventanas
de una manera mas ligera y rápida que anteriormente.
Kitkat 4.4
En esta versión los componentes principales de Android son
recortados para reducir el uso de la memoria del equipo, y se
crea una API nueva la cual permite trabajar las aplicaciones
con un uso menor de memoria.
Se mejora la conectividad con soporte de NFC para emular

tarjetas de pago tipo HCE, varios protocolos sobre Bluetooth y
soporte para mandos infrarrojos. También se mejoran los
sensores para disminuir su consumo y se incorpora un sensor contador de
pasos.
Se facilita el acceso de las aplicaciones a la nube con un nuevo marco de

almacenamiento. Este marco incorpora un tipo específico de content
provider conocido como document provider, nuevas intenciones para abrir y
crear documentos y una ventana de dialogo que permite al usuario seleccionar
ficheros. Se incorpora un administrador de impresión para enviar documentos a
través de WiFi a una impresora. También se añade un content provider para
gestionar los SMS.
Lollipop Android 5.0

La versión 5.0 permite la extensión hacia unas nuevas
plataformas como son Google Wear, Google TV y Google
Card. Además hay un gran cambio con respecto a la
máquina virtual ART en lugar de Dalvik. Además se incluye
aplicaciones como son Chrome, GMmail, entre otros.
También podemos rescatar que en esta versión el modo de
ahorro de batería se activa de forma automática y no requiere la confirmación
del usuario haciendo que automáticamente se desconecten algunos
componentes.
Con respecto al diseño de la interfaz se han incluido botones en la parte inferior

(Retroceder, Inicio y Aplicaciones), que ahora son un triángulo, un círculo y un
cuadrado.

Además la nueva versión cuenta con un modo de bloqueo que impide al

usuario salir de una aplicación y bloquea las notificaciones. Esto podría
utilizarse, por ejemplo, para que mientras un usuario realiza un examen, no
pueda ver las notificaciones, acceder a otras aplicaciones, o volver a la pantalla
de inicio.
ARQUITECTURA ANDROID.
El núcleo de Linux.
Android tiene como núcleo al sistema operativo Linux versión la cual es una
capa que proporciona los servicios necesarios para brindar un manejo de
memoria adecuado, una seguridad muy buena y manejo de protocolos y drivers
al mayor alto nivel.
Runtime de Android.
El Runtime se basa en una máquina virtual la cual utiliza Java para poder
utilizar sus funciones. En vista de que los sistemas operativos Android corren
en dispositivos móviles los cuales no cuentan con la memoria suficiente como
para que ejecute una máquina virtual de Java, Android tuvo que crear su propia
máquina virtual basada en Java su nombre es Dalvik la cual responde a las
acciones del móvil de una mejor manera y se adapta a cualquier dispositivo
móvil.
Librerías nativas.
Android incluye una serie de librerías las cuales son usadas sin necesidad de
archivos adicionales o instalación de algún Framework. A continuación
mostramos algunas de las librerías que se incluyen en el sistema operativo:
- System C library.
- Media Framework.
- Surface Manager: permite el trabajo con gráficos 2D y 3D.
- WebKit: Permite trabajar con los modernos navegadores web.
- SGL: motor de gráficos 2D.
- Librerías 3D: Permite trabajar con proyecciones 3D.
- FreeType: fuentes en bitmap y renderizado vectorial.
- SQLite: Potente administrador de base de datos que viene incluido en el
paquete de de Android.
- SSL: proporciona servicios de encriptación.
Entorno de aplicación.
Android proporciona una plataforma muy amigable y muy innovadora la cual
nos permite trabajar con todos los recursos del móvil como son el caso de

sensores que vienen incluidos en el dispositivo, localización que nos sirven

para trabajar con GoogleMap y GPS, servicios Web entre otros.
La ventaja más resaltante de utilizar el entorno de desarrollo es que aprovecha

el lenguaje JAVA, el cual es un potente lenguaje de programación el cual unido
con el entorno grafico permite realizar aplicaciones con gran nivel y gran
potencia.
Los servicios más importantes que incluye son:
- Views: Son las vistas que no sirven para el diseño.

- Resource Manager: permite almacenar y administrar recursos con los
cuales se trabajara en las aplicaciones.
- Activity Manager: maneja el ciclo de vida de las aplicaciones y proporciona
un sistema de navegación entre ellas.
- Notification Manager: Muestra las alertas en la barra de estado.
- Content Providers: Permite trabajar con datos en especial cuando se
trabaje con arreglos, matrices o base de datos.
Aplicaciones:
En este nivel se encuentran todas las aplicaciones instaladas en el dispositivo
móvil, todas estas son controladas y corridas por la máquina virtual Dalvik.
Todas las aplicaciones Android están programadas a base de Java, aunque en

la actualidad existen otras alternativas, pero todas utilizan las librerías del SDK.

ACTIVIDADES DE REPASO E INVESTIGACIÓN.
1. Mencionar 20 empresas las cuales integran la Open hanset Alliance.

2. Menionar 5 Caracteristicas del sistema Operativo Android.
3. Mencionar 5 caracteristicas del sistema operativo IOs.
4. Mencionar 5 Caracteristicas del sistema operativo Windows Phone.
5. Mencionar 5 caracteristicas del sistema operativo firefox OS.
6. Mencionar 5 caracteristicas del sistema operativo BackBerryu.
7. Crear un cuadro comprativo sobre todas las versiones del sistema operativo
android mostrando como minimo 3 diferencias entre cada una de ellas.

II. INSTALACIÓN Y CONFIGURACIÓN DE ECLIPSE.
OPERACIONES:
- Conocer los tipos de descarga de Android Studio y el SDK Manager.
- Conocer los diferentes tipos y diferencias de las máquinas virtuales que se
pueden configurar.
- Sistema operativo Windows con Android Studio instalado.
ANDROID STUDIO.
Cuando Google lanzo al mercado el sistema

operativo Android los programadores
comenzaron a volcar sus conocimientos hacia
este nuevo sistema operativo, llegando a
programar aplicaciones y juegos realmente espectaculares. La creación de las
aplicaciones se hacía a través de un sistema operativo muy conocido llamado
Eclipse el cual permitía trabajar en un entorno grafico todas las aplicaciones
que el desarrollador deseará.
A mediados del 2013 Google anunció la aparición de un nuevo Software el cual

ayudaría a los desarrolladores a crear sus aplicaciones de una manera más
versátil, ligera y más segura, su nombre seria ANDROID STUDIO, el cual se
convertirá en el software oficial de Google para la creación de Aplicaciones
Móviles.
Android Studio es un IDE basado en Java que permite crear aplicaciones

haciendo uso del entorno gráfico.
Una de las grandes ventajas que tiene el programa Android Studio es que nos
permite ver los cambios conforme se van desarrollado , es decir en directo,
además tenemos que Android Studio permite la integración con Google Cloud
Messaging, esto hace que el desarrollador no tenga que salir del programa.
Características:
- Renderización y pruebas en tiempo real.
- Soporte de desarrollo en la construcción basada en Gradle.
- Refactorización especifica de Android y arreglos rápidos.
- Plantillas para crear diseños comunes de Android y otros componentes.

- Soporte para programar aplicaciones para Android Wear.
Requisitos del Sistema:

- 2 GB de RAM (4 GB recomendados).
- 400 MB de espacio en disco.
- 1 GB para Android SDK.
- Monitor de 1280x800
- Java Development Kit 7.
- Para GNU/Linux: GNU Library C 2.15 o superior
Descarga Android Studio SDK y Plugins Instalacion de JDK.
 Ingresar a la siguiente ruta

http://www.oracle.com/technetwork/es/java/javase/downloads/index.html
 Hacemos clic al ícono de JAVA.
 Se mostrará la siguiente ventana donde se aceptará la licencia y se

procederá a escoger la versión de JAVA adecuada para su PC.
 Una vez hecha la descarga se encontrará el siguiente ícono al cual se le

dará doble clic para iniciar la instalación.

 Click en next.
 Click en NEXT nuevamente.
 Clic en NEXT.
 En general la instalación de este software es muy sencillo ya que vienen las

opciones por defecto hasta que al final CLOSE.

 Ahora, hay que definir el JAVA_HOME, como variable de sistema. Para ello
Damos clic derecho sobre “Este Equipo” (o icono similar, antes se llamaba
“mi pc”) y escogemos PROPIEDADES.
 Del menú del lado izquierdo, se escogerá la opción de CONFIGURACIÓN

AVANZA DEL SISTEMA
 En la pestaña de OPCIONES AVANZADAS, se dará clic en el botón

de VARIABLES DE ENTORNO…

 Debajo de la segunda lista de VARIABLES DE SISTEMA, se dará clic en el

botón NUEVA.
 Y se teclean, los valores de JAVA_HOME y la ruta, a donde se instaló el

SDK de Yaba, se dará clic en ACEPTAR.
 Nos regresar a listas anteriores, y ahora ver la nueva variable de sistema,

dar clic en ACEPTAR.

DESCARGA, INSTALACIÓN Y CONFIGURACIÓN DE ANDROID STUDIO.
 Ingresar a la siguiente dirección web para descargar el instalador:

http://developer.android.com/intl/es/sdk/index.html
 Se mostrará la siguiente ventana. En esta ventana se mostrará el botón

DOWNLOAD ANDROID STUDIO. Se le da clic y mostrará la siguiente
ventana:
 En esta ventana se aceptan las condiciones y se le da clic en el botón

DOWNLOAD.
 Una vez descargado el sistema operativo se mostrará el siguiente ícono de

instalación. Una vez que se tiene el instalador, dar clic derecho y
EJECUTAR COMO ADMINISTRADOR.

 Dar clic en NEXT.
 Dejar las opciones por defecto y dar lic en NEXT.
 Aceptar el acuerdo de licencia, y dar clic en I AGREE.

 La ventana anterior muestra donde colocar los archivos del Android studio y
la segunda donde colocar las librerías del SDK, se pueden cambiar las rutas
que vienen por defecto o podemos dejarlas hay, en cualquiera de los casos
NEXT.
 Ahora se muestra un mensaje de advertencia, que la ruta, que se escogió,

no está en la carpeta de usuario de Windows, pregunta si se quiere corregir
esto, o seguir con mi opción. Dar clic en NO.
 Por último se da clic en el botón INSTALL.
 Cuando se ermine la instalación dar clic en NEXT.

 Por último el instalador pregunta si se desea abrir o no el Android studio, si

se ha escogido carpetas de instalación distintas a las que viene por defecto
se deci que no porque se necesita darle algunos permisos antes de abrir
Android Studio. Luego clic en FINISH.
 Si la opción fue escoger otras carpetas se tiene que ubicar la carpeta en

donde se realizó la instalación y dar clic derecho y clic en PROPIEDADES.
 Se quita el check de “Solo Lectura…” y clic en ACEPTAR.

 Se mostrará un mensaje preguntando “Aplicar cambios a esta carpeta y

todas las subcarpetas y archivos” … clic en ACEPTAR.
 Piedir permisos de Administrador, clic en CONTINUAR.
 Luego, cuando se termine, dar clic a la lengüeta de SEGURIDAD, y clic

en EDITAR.

 A todas las opciones de la primera lista, dar clic en los 2 primeros checks de
la segunda lista (CONTROL TOTAL, MODIFICAR), luego clic en ACEPTAR.
 Al finalizar todo el proceso buscar el ícono de instalación y dar doble clic

sobre el mismo para iniciar Android Studio.

 Cuando se le da doble clic, pedirá instalar las herramientas faltantes por lo

tanto dejar que se actualice.
 Cuando se termine, se quitará la barra de progreso y se dará clic en el botón

de FINISH.
 Luego de todo el proceso se mostrará la siguiente ventana de bienvenida

donde se dará clic en START A NEW ANDROID STUDIO PROJECT.
INSTALACIÓN Y CONFIGURACIÓN DE LA MÁQUINA VIRTUAL.
Para poder correr la máquina virtual se requiere de la instalación del Intel xd

emulador que se encuentra en el SDK Manager.

 Hay que aceptar la licencia y dar clic

en INSTALL.
 Después de terminar, buscar dentro de la carpeta del SDK de Android, la de

EXTRAS y ahí la de INTEL y ejecutar el archivo intelhaxm-android.exe
 Para ejecutar la aplicación sobre una máquina

virtual de Android se le tiene que dar clic en el
botón RUN o el icono de Play de color verde.
 Se mostrará un ventana con dos opciones,

una de escoger un teléfono conectado vía
USB (más adelante hablaremos de ese
show), y la segunda, de LAUNCH
EMULATOR. Escoger la segunda y OK.

Crear una aplicación que permita mostrar sus datos personales,

haciendo uso de la herramienta textView.
Este ejercicio permitirá conocer la forma de crear un proyecto y

como utilizar los controles básicos.
1. Abrir Android Studio y crear un nuevo proyecto. Click en File – New Project.
2. Escribir el nombre del proyecto, el

nombre del paquete y seleccionar la
carpeta de donde se creará el nuevo
proyecto.
3. Seleccionar la versión mínima requerida.

4. Seleccionar el tipo de actividad.
5. Por último, colocar el nombre a la actividad principal, también el nombre al

layout, el título de la clase principal y el nombre del menú que se mostrará
por defecto
En la paleta de herramientas buscar la herramienta textView la cual servirá

para mostrar los textos que se desean, como serán el nombre, dirección,
semestre, etc.
Los controles serán arrastrados hacia la pantalla del móvil (layout), una vez
colocados en las posiciones correctas se procederá a cambiar el contenido de
los textos dándole doble clic sobre cada uno de los controles.

Modificar los colores de las etiquetas haciendo uso de la propiedad textColor

de la ventana de propiedades.
Se podrá Configurar la presentación de la pantalla a

su propio criterio. Ejecutar la aplicación. El resultado
será el siguiente:
1. Utilizando Android Studio crear una aplicacion la cual muestre los datos de la
carrera que esta cursando (Nombre de la carrera, Ciclo, Institucion
Educativa, etc), solo se hara uso del control textView.
2. Aplicar un formato adecuado (Color de fondo, tamaño de fuente, estilos, etc)

III. ENTORNO DE DESARROLLO – ANDROID - GUI.
OPERACIONES:
- Conocer y configurar el entorno de trabajo de un proyecto Android.
ESTRUCTURA DE UN PROYECTO ANDROID.
Cuando se crea un proyecto en Android Studio, este genera su propio entorno

de trabajo o su propio esqueleto de directorios la cual es común en todos los
proyectos facilitando así, la organización de los archivos de la aplicación.
Carpeta SRC.
En esta carpeta se encuentran las clases llaves la cual contiene el código
fuente del proyecto, además contiene el código de la interfaz gráfica. Además
al momento de que Android Studio crea su proyecto, este crea una pantalla
llamada activity_main la cual se enlaza automáticamente con el proyecto
mediante la clase.
Carpeta RES.
Esta carpeta contiene todos los recursos que necesita el proyecto tal es el caso
de imágenes, sonidos, videos, archivos de texto, etc. De acuerdo al recurso
este se alojará en una subcarpeta la cual estará creada dentro de la carpeta
RES y almacenará un tipo de archivo específico. Todos los archivos tendrán
una ubicación específica de acuerdo a su tipo.
No todas las carpetas tienen que aparecer en un

proyecto y no todas tienen que ser usadas, se usarán
sólo las que se necesiten colocar algún recurso. A
continuación se mostrarán las carpetas que se crean por
defecto:
Una de los archivos creados por derecho es el layout

principal de nombre activity_main.xml, el cual será la
pantalla principal que reconocerá el proyecto en el cual
se colocarán los controles. Esta interfaz simulará un

móvil y puede ser cambiada de dimensiones en la barra superior pudiéndolo

acoplar a otros tipos de ventana. A partir de esta ventana, que viene por
defecto, se podrán crear otras y ser llamadas entre sí.
Durante el desarrollo de la
aplicación se utilizará demasiado
en entorno de desarrollo gráfico, ya
que es aquí donde se manipulará el
aspecto que tendrán las pantallas
del proyecto. Existe otra alternativa
de trabajar el diseño de la interfaz y
es mediante el código XML, todas
las pantallas tienen asociados un
código llamado XML. En este caso, el XML asociado sería el siguiente:
Este tipo de interfaz de código puede resultar más complicado, pero en realidad
el utilizar este tipo de ventanas se hace más sencillo.
Carpeta GEN.
Cada vez que se ejecuta o compila un proyecto, la máquina genera
automáticamente identificaciones y códigos para cada uno de los elementos y
cada una de las partes del código para su identificación; por lo tanto, en la
carpeta GEN se encuentra todo el registro de elementos con los que cuenta la
aplicación.
Para poder acceder a los recursos o códigos de identificación de cada uno de

los elementos de la aplicación se hace por medio de la variable global R. Cada
vez que se llama a esta variable global se estará accediendo a todos los
registros e identificaciones de los controles, de forma que se pueda
rapidamenete acceder a dicha carpeta.

Carpeta ASSETS.
Esta carpeta contiene todos los archivos auxiliares que pueda necesitar la
aplicación o proyecto que se está creando (y que se incluirán en su propio
paquete), como por ejemplo ficheros de configuración, archivos adicionales,
archivos planos, música, videos, etc.
Cada vez que se quiere acceder a los recursos con los que cuenta esta carpeta
se hace a través de un comando denominado ASSETMANAGER que significa
administrador de recursos, este comando permitirá acceder a todos los
recursos y archivos con los que cuenta el sistema.
Carpeta BIN.
En esta carpeta se encuentran los archivos compilados de la aplicación y otros
fiches de tipo auxiliar. Esta carpeta es una carpeta que por lo general no se
toca ya que pueden eliminar archivos necesarios para la compilación o
ejecución del proyecto.
Carpeta LIBS
En esta carpeta se encontrarán lbrerías adicionales con los que trabajará el
proyecto, por lo general, son archivos de tipo JAR.
FICHERO ANDROIDMANIFEST.XML.
Este es un fichero muy importante ya que en este fichero se colocarán los

permisos necesarios para que la aplicación pueda realizar ciertas acciones; por
ejemplo, permisos que utilizan los sensores, permisos para uso de internet, etc.
INTERFAZ GRAFICA DE USUARIO.
Los componentes o elementos de diseño en una actividad o comúnmente

llamados controles descienden de la clase View. La clase View es una clase
que viene por defecto y es la que almacena todos los atributos y métodos de
los controles que utilizamos en el diseño de pantallas.

Las vistas o Views se definen de la siguiente manera:
- Fichero XML. Este fichero se coloca dentro del directorio res/layout en el

cual se almacenarán siempre todos los layout o ventanas de diseño.
- Tiempo de ejecución. Cuando la aplicación se está ejecutando también se
pueden crear ficheros o layouts con controles para determinadas acciones.
Para poder crear una interfaz lo primero que se tiene que hacer es pasar a la
raíz el objeto View y así ir descendiendo a cada uno de sus nodos. El método
que se encarga de este proceso se llama Activity.setContentView ().
Para que Android sepa dibujar correctamente los objetos, se tienen que pasar
algunos datos, como son la altura y anchura, éstas puede ser en pixeles o en
porcentajes. Además Android cuenta con los siguientes tipos para poder
trabajar las dimensiones de los controles:
- Números.
- FILL_PARENT, permite al control tomar el ancho máximo o alto máximo del
contendor padre en el cual se encuentra.
- WRAP_CONTENT, igual que el anterior esta permite tomar el ancho máximo
permitido respeto al padre donde se encuentra.
- AT_MOST, el padre fija un tamaño de los controles hijos.
- EXACTLY, el padre impone un tamaño exacto al hijo.
- UNSPECIFIED, el padre fija el tamaño deseado del hijo.

Uno de los atributos más importante es el ID que es de tipo entero, este

atributo sirve para identificar a cada uno de los elementos del View. Las
maneras de cómo declarar son las siguientes:
- android:id=”@+id/nombreID”: Crea un nuevo atributo en la clase R

llamado nombreID.
- android:id=”@id/nombreID”: Hace referencia a un id ya existente asociado
a la etiqueta 'nombreID'
- android: id=”@android: id/list”: Referencia a una etiqueta definida en la
clase R del sistema llamada ‘list’.
Context.
Context es una interfaz mediante al cual se puede acceder a los recursos,
clases y otros elementos con los que cuenta el proyecto, además se podrán
manipular los intent y otras vistas.
- getContext(). Método de acceso al contexto.

- Cuando se quiere hacer referencia a una misma clase o enviarla como
contexto se utiliza la palabra reservada this, la cual hace referencia a la
misma clase, permitiendo el uso de todos sus elementos.
- Usando otros métodos como getApplicationContext() o getApplication()
- Los layout permiten posicionar cada objeto gráfico en el lugar que se quiera
de la pantalla, esto permite diseñar el entrono de desarrollo o el entorno
gráfico que va a llevar la aplicacion. Los layouts son de tipo ViewGroup, una
subclase de View
CREACIÓN DE UNA INTERFAZ DE USUARIO USANDO XML EN ANDROID.
Android permite el diseño de interfaces tanto en modo gráfico; así como

también, utilizando código XML, como se mencionó anteriormente el uso de
código XML facilita la creación de la interfaz, haciendo un poco más entendible
el diseño. Es sólo cuestión de costumbre para utilizar este tipo de comandos.
Para poder crear diseños a través de códigos XML primero se tiene que
acceder al archivo /res/layout/main.xml del proyecto. Este layout mostrará un
código similar al siguiente:

En realidad resulta muy sencillo interpretar los códigos mostrados ya que en la

parte superior se puede observar que se inicia toda la anidación de elementos
con un layout y dentro de este layout se encuentra un único control que viene
por defecto el cual es un textView, a partir de esos código se puede ir creando
o agregando controles dentro del layout, incluso se puede ir anidando los
controles uno dentro de otro.
1. ¿Qué se puede almacenar en la carpeta Libs?

2. ¿Qué se encuentra en la carpeta Res?
3. ¿Qué se puede almacenar en la carpeta Assets?
4. ¿Para qué sirve un fichero XML?
5. ¿Qué se encuentra en la carpeta values?
6. Crear una aplicación la cual contenga datos personales. La aplicacion será
creada a base de codigos XML.

IV. CREACIÓN DE UNA APLICACIÓN ANDROID.
OPERACIONES:
- Crear la primera aplicación Android y ejecutar la aplicación en el emulador.
Desplegar una aplicación en emulador y dispositivo real.
En el ejemplo se creará una pantalla donde se ingresarán datos

como el nombre, la edad de un usuario y un checkbox donde se
seleccionará en caso el sexo del usuario sea masculino. Al
ejecutar la aplicación se mostrará un mensaje con los datos
registrados.
1. Primero se tienen que crear todos los objetos que van a requerir los
controles de la aplicaciones, nos referimos a los String(los textos), los
style(los colores), las dimensiones (tamaños).
2. Luego, ingresar al XML del Activity_main y digitar:
<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_alignParentTop="true"
android:layout_alignParentLeft="true"
android:layout_alignParentStart="true">
<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:textAppearance="?android:attr/textAppearanceLarge"
android:text="Programando con Android"
android:id="@+id/textView"
android:layout_gravity="center_horizontal" />
<TextView
android:textAppearance="?android:attr/textAppearanceMedium"
android:text="Ingrese Nombre:"
android:id="@+id/textView2"
android:layout_marginTop="30dp" />
<EditText
android:id="@+id/editText" />
<TextView
android:text="Ingrese Edad:"
android:id="@+id/textView3" />
<EditText
android:id="@+id/editText2" />
<TextView
android:text="Seleccione en caso de Masculino:"
android:id="@+id/textView4" />

<CheckBox
android:text="New CheckBox"
android:id="@+id/checkBox" />
<Button
android:layout_width="fill_parent"
android:text="Grabar Datos"
android:id="@+id/button"
</LinearLayout>
</RelativeLayout>
Luego proceder a la programación en la clase Java:

public class MainActivity extends ActionBarActivity{
EditText txtNom, txtEdad;

Button btnGrabar;
CheckBox chkSexo;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
txtEdad=(EditText)findViewById(R.id.txtEdad);
txtNom=(EditText)findViewById(R.id.txtNombre);
chkSexo=(CheckBox)findViewById(R.id.chkSexo);
btnGrabar=(Button)findViewById(R.id.btnMostrar);
btnGrabar.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
String sexo="";
if(chkSexo.isSelected())
sexo="Masculino";
else
sexo="Femenino";
Toast.makeText(getApplicationContext(),"Nombre:
"+txtNom.getText()+"\nEdad: "+txtEdad.getText()+"\nSexo:
"+sexo,Toast.LENGTH_LONG).show();
}
});

1. Crear una aplicación la cual contenga dos EditText, un Buton y el textViw,

los editText Recibiran el precio y la cantidad de un determinado producto.
Cuando se presione el botón, la aplicacion calculará la multiplicacion del

precio por la cantidad ingresados y el resultado se mostrará en último
textView, además se mostrará un mensaje (Toast), indicando que el cálculo
se realizó satisfactoriamente.

V. CONFIGURACIÓN Y PROGRAMACIÓN DE CONTROLES BÁSICOS.
OPERACIONES:
- Organizar los elementos de una aplicación.
- Utilizar los diferentes tipos de control de una aplicación.
LAYOUTS (Frame Layout – Linear Layout– Tablet Layout –Relative Layout

– TabLayout).
FrameLayout.
Un FrameLayout permite colocar a todos los controles que se
coloquen sobre la parte superior izquierda de la pantalla de tal
manera que todos los controles se pondrán uno sobre otro,
quedando ocultos cada vez que se coloque un nuevo control.
Por lo general este tipo de layout se usa para mostrar un único

control.
Las propiedades principales con las que cuenta el

FrameLayout son:
Android: layout width.
Android: layout height.
Los cuales podrán tomar los valores:
Match_parent. Permitirá que el layout tome en máximo tamaño con respecto al

contendor o layout que lo contiene.
Wrap_content. Permitirá que el layout tome en máximo tamaño con respecto al

contendor o layout que lo contiene.
NOTA: Si se desarrolla en una versión de la API de Android inferior a la 8

(Android 2.2), entonces en vez de utilizar “match_parent” se debe utilizar
“fill_parent”.
Ejemplo:
<FrameLayout

xmlns: android="http://schemas.android.com/apk/res/android"
Android: layout_width="match_parent"
Android: layout_height="match_parent">
<EditText android:id="@+id/TxtNombre"
android:inputType="text" />
</FrameLayout>
LinearLayout.
Este tipo de layout permite colocar los controles o
contenedores hijos uno después del otro ya sea de forma
horizontal (LinearLayout Horizontal) o vertical (LinearLayout
Vertical), para establecer el tipo de dirección se tiene que
establecer una propiedad la cual es Orientation la cual
permitirá saber si está como horizontal o vertical
Al igual que el layout anterior este también cuenta con las

propiedades de width y height el cual podrán escoger entre Fill
Parent, Wrap Content o match parent según sea el caso.
<LinearLayout
xmlns:android="http://schemas.android.com/apk/res/android"
android:orientation="vertical">
<EditText android:id="@+id/TxtNombre"
android:layout_height="match_parent" />
<Button android:id="@+id/BtnAceptar"
android:layout_height="match_parent" />
</LinearLayout>
TableLayout.
El TableLayout permite distribuir los controles o elementos que se coloquen
sobre él, en forma tabular definiendo filas y columnas, es decir que cada control
se colocaría sobre una celda ya que este control genera una tabla para colocar
todos sus elementos en celdas.
Para poder configurar la cantidad de filas que tendrá la tabla se utiliza una
propiedad llamada tableRow la cual permitirá aumentar o disminuir la cantidad
de las filas y dentro de cada fila se colocarán las columnas necesarias.

Para controlar la cantidad de columnas con las que

contará el tableLayout no existe ninguna propiedad o
control para eso, eso se determina conforme se va
agregando componentes a la ventana, por cada
elemento que se esté poniendo las celdas se van
aumentando con respecto a sus columnas de una en
una, por lo general cada columna tiene el ancho de
sus elementos pero a base de propiedades estas
columnas pueden variar su tamaño. A continuación
se muestran algunas propiedades:
- android: stretchColumns. Permitirá que las columnas se puedan expandir

para quitar el espacio libre dejado por las demás columnas a la derecha de
la pantalla.
- android: shrinkColumns. Permitirá que las columnas puedan reducir su
tamaño permitiendo más espacio al resto de columans evitando que éstas
desborden el lado derecho de la pantalla.
- android: collapseColumns. Permitirá que las columnas de la tabla se puedan
ocultar completamente.
GridLayout.
Este tipo de layout fue includo a partir de la API 14 y su forma de trabajar es
bastante parecida a la de un TableLayout, ya que en este tipo de layout los
elementos que se coloquen dentro de él también serán distribuidos en forma de
tabla; es decir, se colocarán en una especie de celda ya que se distribuirán por
filas y columas.
La gran diferencia que existe de este control con el tableLayout es que en éste
se puede colocar la cantidad de filas y de columnas con las que contará la tabla
gracias a sus propiedades rowCount y columnCount, Con estas propiedades
ya no es necesario ningún tipo de elemento adicional como lo hacía el Table
Layout para agregar filas a la tabla.
RelativeLayout.
Este tipo de layout permite colocar los controles u objetos que van dentro de
este layout de forma aleatoria; es decir, para colocar estos elementos sólo se
tendrá que arrastrar el control sobre la pantalla y escoger la posición adecuada.
Cuando se encuentre la posición adecuada simplemente se soltará el mouse y
el control quedará en esa posición. Cuando se quiera insertar más controles se
mostrarán unas líneas guías para que se pueda alinear y ordenar los controles
con respecto al padre.

CONTROLES BÁSICOS.
Control Button.
Este control es uno de los más básicos y más
usados en una aplicación ya que este botón
permitirá lanzar o realizar cierta acción cuando
se haga un Touch sobre este control.
Una de las principales propiedades del control es la propiedad text la cual

permite cambiar el texto que se muestra sobre el control. La declaración de
este control mediante XML sería la siguiente:
<Button
android:text="Calcular Venta"
android:id="@+id/BtnCalcular"/>
Control ToggleButton.
Este tipo control también permite lanzar ciertas acciones, pero este botón tiene
la particularidad de trabajar con 2 estados los cuales son pulsados y no
pulsado. Por lo tanto, para este control en vez de definir un solo texto se
definen dos, una cuando esté activo y otro cuando se desactive. La declaración
de este control mediante XML es la siguiente:
<ToggleButton
android:text="Activar"
android:id="@+id/toggleButton"
android:checked="false" />
Control ImageButton.
Este tipo de control es igual al control de tipo Button, con la única diferencia
que en este control se podrá definir un ícono para el botón en vez de texto.
Para asignar un ícono en vez de texto se tiene que hacer uso de la propiedad
src la cual permitirá asignar un ícono el cual ha debido ser previamente
cargado en las imágenes del proyecto. Su código XML es el siguiente:
<ImageButton
android:id="@+id/imageButton"

Eventos de un botón.
Como en todo lenguaje de programación, se puede decir que el evento más
común es el evento click. Este evento permite lanzar una acción cuando se
toca el botón. Este evento trabaja con objetoView.OnClickListener () y
asociándolo al botón mediante el métodosetOnClickListener (). La forma de
declaración de ese evento en una clase sería la siguiente:
btn1=(Button)findViewById(R.id.button);
btn1.setOnClickListener(new View.OnClickListener() {
@Override
}
});
Control ImageView.
El control ImageView permite colocar imágenes dentro de la aplicación. Para
poder insertar una imagen dentro del control se tiene que utilizar la propiedad
src la cual permite cargar una imagen que previamente ha sido colocada dentro
del proyecto. En la carpeta Drawable, por ejemplo android:
src=”@drawable/unaimagen”.
Además, también se pueden modificar sus propiedades como son el alto y el

ancho mediante las propiedades: android:maxWidth y android:maxHeight, o
para indicar cómo debe adaptarse la imagen al tamaño del
control,android:scaleType (5=CENTER, 6=CENTER_CROP,
7=CENTER_INSIDE, …).
La declaración de un control ImageView dentro del código es el siguiente:
img1=(ImageView)findViewById(R.id.imageView);
Control TextView.
Este tipo de control al igual que el control Button son los más utilizados, este
control permite colocar cualquier tipo de texto dentro de la aplicación en la
ubicación que se desee. Al igual que muchos de los controles el texto se
establece por medio de la propiedad text.
Si lo que se desea es cambiar el color de fondo de la etiqueta se podrá utilizar

la propiedad: android: background, si lo que se desea es cambiar el color de
texto se tendrá que utilizar la propiedad: android: textColor, si se desea cambiar
el tamaño del texto se utilizara: android: textSize, si se desea cambiar el estilo
de fuente entonces se utilizara: android: typeface (estilo del texto: negrita,
cursiva). La programación de dicho control en XML seria la siguiente:

<TextView
android: layout_width="wrap_content"
android:textAppearance="?android:attr/textAppearanceLarge"
android:text="Texto Ejemplo"
android:id="@+id/textView"
android:layout_centerHorizontal="true"
Control EditText.
Este control es un control que permite ingresar valores de tipo cadena o
numérico cuando la aplicación está ejecutándose, igual que los otros controles
se podrá ingresar un texto mediante la propiedad text o cambiarle el alto o
ancho mediante la propiedad width o heigth.
Una de las propiedades más importantes de este control es la propiedad

android:inputType. La cual indicará el tipo de contenido que se va a introducir
en el cuadro de texto. La declaración Del control mediante XML sería la
siguiente:
<EditText
android:id="@+id/editText"
Control CheckBox.
Este tipo de control permite escoger una o varias opciones de un grupo, este
control permite marcar o desmarcar las posibles opciones y en Android está
representado por una clase del mismo nombre CheckBox.
La declaración del control mediante XML sería de la siguiente manera:
<CheckBox
android:text="New CheckBox"
android:id="@+id/checkBox"

Control RadioButton.
A diferencia del control anterior, este control permite escoger sólo un elemento
de un grupo de opciones, ya que este control impide la selección de más de
uno por grupo. Este control tiene que trabajar obligatoriamente con un control
llamado RadioGroup, el cual es un control no visible que lo que hace es
agrupar las opciones para que estas no se puedan seleccionar varias a la vez;
de lo contrario, se estaría hablando un control de tipo checkBox. Su declaración
mediante XML seria de la siguiente manera:
<RadioGroup
android:layout_centerVertical="true"
android:layout_centerHorizontal="true">
<RadioButton
android:text="New RadioButton"
android:id="@+id/radioButton" />
<RadioButton
android:id="@+id/radioButton2" />
<RadioButton
android:id="@+id/radioButton3" />
</RadioGroup>
Gridview.
Este tipo de control permitirá colocar una serie de elementos de forma
cuadricular. Cuando se trabaja con este tipo de elementos uno puede elegir el
tamaño y la cantidad de columnas que va a tener dicho elemento, en cambio el
número de filas se coloca de una manera dinámica que se coloca en función al
número de ítems.
Al trabajar con este control tenemos propiedades que nos ayudaran a trabajar
con las columnas respectivas. Tal es el caso de:
- android: numColumns, permite colocar el número de columnas que va a

tener el gridView, si se le coloca el valor auto_fit en este atributo, android
calcular el número de columnas con respecto al espacio con que cuente la
pantalla.

- android:verticalSpacing y android:horizontalSpacing, permite colocar el

espacio en blanco que debe existir entre cada uno de los elementos de la
cuadricula.
- android:columnWidth, permite colocar el ancho a cada una de las
cuadriculas.
- android:stretchMode, permite indicar cómo debe aprovechar el móvil los
espacios que no se estén utilizando; es decir, los espacios en blanco, qué
columna debe expandirse y así aprovechar él o los espacios en blanco.
public boolean onOptionsItemSelected(MenuItem item) {

switch (item.getItemId()) {
case R.id.Salir:
Toast.makeText(
MenusActivity.this,"Utilizando MENUS" ,Toast.LENGTH_LONG).show();
return true;
case R.id.pantalla2:
finish();
return true;
default:
return super.onOptionsItemSelected(item);
}
}
Context Menu
Los menús contextuales son parecidos a los menús mostrados al hacer clic con
el botón derecho de un ratón en un PC, para crearlos, debemos sobreescribir el
método onCreateContextMenu(), donde se inflará el archivo xml.
@Override
public void onCreateContextMenu(ContextMenu menu, View v,ContextMenuInfo
menuInfo) {
super.onCreateContextMenu(menu, v, menu2);
MenuInflater inflater = getMenuInflater();
inflater.inflate(R.menu.menu2, menu);
}
Igual que el menú anterior a este tipo de menú también se le puede dar
acciones. A continuacion se muestra el bloque de código para programar el
contextMenu:
@Override
public boolean onContextItemSelected(MenuItem i) {
switch (i.getItemId()) {
case R.id.about:
Toast.makeText(MenusActivity.this,"menus",Toast. LENGTH_LONG). show();
return true;
case R.id.pantalla2:
finish();

return true;
default:
}
}
Este tipo de menú no se muestra a no ser que lo asociemos a una pulsación

prolongada en una pantalla o algún control. Mostramos el ejemplo de cómo se
verían los controles:

Cuadros de diálogo y Toast.

Un mensaje de tipo TOAST es un mensaje el cual permanecerá activo en
pantalla por un lapso de tiempo corto, este mensaje desaparece sólo, sin
necesidad de que el usuario pueda accionar o activar algo.
Por sus características, este tipo de mensajes son ideales para mostrar
mensajes rápidos y sencillos ya que no requieren ningún tipo de información
adicional.
Menus y Tabs
Los menus son uno de los elementos también muy importantes dentro de los
móviles ya que los menus siempre están presentes en las aplicaciones;
generalmente, se activan con los botones que se encuentran en la parte inferior
del móvil y este abre opciones de ayuda o configuración pero en realidad debe
hacer cualquier tipo de acción.
Se tiene el siguiente tipo de menus:
- Options Menu: Se despliega al pulsar la tecla menú.

- Icon menu: Muestra íconos en todas las opciones del menu, pero sólo
acepta hasta 6 elementos como máximo.
- Expanded Menu: Se utiliza cuando se han colocado más de 6 elementos,
mostrando un elemento con la palabra “Más”.
- Context Menu: Son Menus contextuales los cuales se displayan al realizar
una pulsación larga en la vista.
- Submenús: Son los menus que se encuentran dentro de cada uno de los
menus y serán mostrados cuando se escoja una opción del menu.
Options Menu.
Los OptionMenu vienen a ser los ítems o las opciones de cada uno de los
menus, estos viene a ser los más fáciles de definir. A continuación mostramos
un ejemplo de cómo se declara un menú dentro de un XML:
< ?xml version="1.0" encoding="utf-8"?>

<menu xmlns:android="http://schemas.android.com/apk/res/android">
<item android:id="@+id/Salir"
android:icon="@drawable/Salir"
android:title="About App">
<menu xmlns:android="http://schemas.android.com/apk/res/android">
<item android:id="@+id/Menu2"
android:title="Este es el Segundo menu"/>
</menu>
</item>
<item android:id="@+id/Pantalla2"
android:title="Ir a configuracion"

android:icon="@drawable/configuration"/>
</menu>
Cada vez que se requiera llamar a un menu se tiene que hacer uso del
comando MenuInflater.inflate(), el cual permitirá inflar el menu en cada una de
las pantallas en que se llame. A continuación se muestra el código que
permitirá inflar las opciones.
@Override
public boolean onCreateOptionsMenu(Menu menu) {
inflater.inflate(R.menu.ejemplo_menu, menu);
return true;
}
Ahora si es que el usuario le desea colocar las acciones a cada una de las
opciones se utilizará el comando onOptionsItemSelected() el cual permitirá
programar cada uno de los itmes que contiene el menu.
Se creará una aplicación la cual permitirá leer el nombre escrito

en un editText y este permita mostrar un mensaje de bienvenida.
public class MainActivity extends Activity {

Button btn1;
EditText txtNom;
Button btnBienvenida;
@Override
txtNom=(EditText)findViewById(R.id.btnBienvenida);

btnBienvenida=(Button)findViewById(R.id.btnBienvenida);
btnBienvenida.setOnClickListener(new View.OnClickListener() {
@Override
String texto=txtNom.getText().toString();
Toast.makeText(getApplicationContext(),"Bienvenido a Android
"+texto,Toast.LENGTH_LONG).show();
}
});
} }
Crear una aplicación que permita ingresar el nombre de un

alumno. Seleccionar un curso (control RadioButton) y
seleccionar el tipo de descuento (control checkBox). Cuando
se tengan todos datos requeridos clic en el botón, calcular
precio. Los resultados como el nombre, el curso, el costo del
curso, los descuentos y el total a pagar y la imagen
representativa del curso se mostrarán en un segundo intento.
1. Crear el diseño de las pantallas de la aplicación.

2. Programar el src de la primera actividad.

public class MainActivity extends ActionBarActivity {

Button btn1;
@Override
btn1=(Button) findViewById(R.id.btnCalcular);
@Override
if(v == btn1) {
RadioGroup rg;
rg = (RadioGroup) findViewById(R.id.rgOpciones);
int precio = 0;
String curso = "";
if (rg.getCheckedRadioButtonId() == R.id.rb1) {
precio = 200;
curso = "Net";
} else if (rg.getCheckedRadioButtonId() == R.id.rb2) {
precio = 300;
curso = "Mysql";
} else {
precio = 350;
curso = "Jsp";
}
double dscto = 0, dsctobeca = 0;
CheckBox chk1;
chk1 = (CheckBox) findViewById(R.id.chkDscto1);
if (chk1.isChecked()) dscto = precio * 0.10;
CheckBox chk2;
chk2 = (CheckBox) findViewById(R.id.chkDscto2);
if (chk2.isChecked()) dsctobeca = precio * 0.10;
EditText nom;
nom = (EditText) findViewById(R.id.txtNom);
String texto1 = nom.getText().toString();
String msg = "El Alumno(a): " + texto1 + "\n Precio: " + precio +
"\n Dscto: " + dscto + "\n Dscto x beca: " + dsctobeca;
String texto2 = String.valueOf(precio);

String texto3 = String.valueOf(dscto);
String texto4 = String.valueOf(dsctobeca);
String texto5 = curso;
Intent i = new Intent(getApplicationContext(),
MainActivity2Activity.class);

i.putExtra("dato1", texto1);
//mostramos el segundo layout
startActivity(i);
}
}
});
3. Programar la segunda actividad:
public class MainActivity2Activity extends ActionBarActivity {
String nom="",precio="",dscto1="",dscto2="",curso="";
Button btn2;
@Override
setContentView(R.layout.activity_main_activity2);
Bundle recupera=getIntent().getExtras();
if(recupera!=null){
nom=recupera.getString("dato1");
precio=recupera.getString("dato2");
dscto1=recupera.getString("dato3");
dscto2=recupera.getString("dato4");
curso=recupera.getString("dato5");
}
TextView mensaje1=(TextView) findViewById(R.id.txtNom2);
TextView mensaje2=(TextView) findViewById(R.id.txtPre2);
TextView mensaje3=(TextView) findViewById(R.id.txtDstco2);
TextView mensaje4=(TextView) findViewById(R.id.txtDscto22);
TextView mensaje5=(TextView) findViewById(R.id.txtcurso2);
mensaje1.setText("Nombre: "+nom);
mensaje2.setText("Precio: "+precio);
mensaje3.setText("Dscto1: "+dscto1);
mensaje4.setText("Dscto2: "+dscto2);
mensaje5.setText("Curso: "+curso);
Button btn2=(Button) findViewById(R.id.btnVolver);
@Override
finish();
}

});
LOS LISTVIEW.
Un listview es un elemento muy importante en la creación de views ya que por

medio de este elementos es que podremos mostrar varios elementos o varios
ítems bajo un mismo control, cuando tengo varios ítems y no entran en la
pantalla la lista podrá deslizarse hacia arriba o hacia abajo según sea el caso
para poder ver todos los elementos. A continuación mostramos un ejemplo
simple de un ListView utilizando un adaptador.
Cuando se crea un ListView se tiene que tener en cuenta que todo listView
necesita de un contendor el cual por lo general es Layout.
Si es que se desea que la lista contenga más de un elemento se tendrá que

utilizar un layout para incluirlo dentro de cada posición, de tal manera que el
layout que ira dentro dentro las características de cada uno de los elementos.
Se tiene que crear una clase y enlazarla con este ListView para que se pueda
visualizar de lo contrario no se podrá visualizar.
Para crear Para utilizar un ListView dentro de un Layout has de usar la

siguiente estructura:
<FrameLayout>
<ListView
android:id="@android:id/list"
... />
<TextView
android:id="@android:id/empty"
... />
</FrameLayout>
Para la creación de nuevos Id o nuevos identificadores se debe utilizar la

siguiente sintaxis:
@+id/nombre_identificador
- El significado del @ es que se trata de un identificador de recurso, osea que

se definirá en la clase R.Java
- El carácter + significa que el id será creado en este momento.

Una vez que ya se ha declaro el control y se ha configurado sus Id entre otras

propiedades tendrá que ser visualizado en una actividad.
En este ejercicio se va a crear una lista y se va a llenar utilizando

un adaptador.
1. Primero se tiene que declarar una lista por medio del xml ya que las lista es
una clase que androide la tiene en sus librerías.
<ListView android: id="@id/android: list"

Android: layout_width="fill_parent"
Android:layout_height="wrap_content" />
2. Luego se colocará la siguiente programación en le src.
public class MainActivity extends ListActivity {
//declaramos un arreglo para llenar la lista

String [] items=new
String[]{"Opcion1","Opcion2","Opcion3","Opcion4","Opcion5","Opcion6","Opcion7"};
//declaramos un objeto tipo lista
ListView lista1;
//declaramos adaptador para llenar los datos
ListAdapter adap;
@Override
//añadimos el ListView a la lista

lista1=(ListView) findViewById(android.R.id.list);
//llenamos el adaptador con los items del arreglo
adap=new ArrayAdapter<String>(this, android.R.layout. simple_list_item_ 1,items);
//llenamos la lista con el adaptador

lista1.setAdapter(adap);
lista1.setOnItemClickListener(new OnItemClickListener() {
@Override
public void onItemClick(AdapterView<?> parent, View v, int
position,long id) {
Toast.makeText(getApplicationContext(),
(String)lista1.getItemAtPosition(position),Toast.LENGTH_LONG).show();
}
});
} }
Control Spinner.
En android los combobox llevan el nombre de Spinner. Los Spinner funcionan
como cualquier combo de algún lenguaje de programación, es decir cuentan
con un índice, y sus elementos, la diferencia es que algunos de acuerdo al tipo
de versión de Android tiene diferente forma de presentación. Los comandos
para añadir una lista mediante códigos XML son las siguientes:
<Spinner android:id="@+id/Sp1"
android:layout_height="wrap_content" />
Cuando el Spiner se quiere declarar en una clase Android, se utilizan los

siguientes comando:
private Spinner cmbOpciones;
//...
cmbOpciones = (Spinner)findViewById(R.id.CmbOpciones);
adaptador.setDropDownViewResource(
android.R.layout.simple_spinner_dropdown_item);
cmbOpciones.setAdapter(adaptador);
Como en el caso de las listas para llenar un Spinner se necesita de un

adaptador, lo primero que se tiene que hacer es llenar el adaptador y este
adaptador es el que va a alimentar el Spinner. Como se ha visto, existen
diferentes tipos de adaptadores, se puede utilizar cualquiera ya que todos
llenan el spinner.
Si lo que se desea es cambiar el aspecto de los elementos del spinner se tiene

la propiedad setDropDownViewResource(ID_layout), el cual permite cambiar

el aspecto de cada uno de los elementos ya que los elementos en el spinner

muchas veces son flotantes.
Haciendo uso de los comandos mostrados hace un momento y colocando el

comando adecuado para mostrar un spinner se puede llegar a tener las
siguientes imágenes.
Puede se puede apreciar en las imágenes, todos los spinner muestran todas
sus opciones y además muestran la opción seleccionada.

Al igual que las listas o ListView los Spinner también cuentan con eventos los
cuales podrán se invocados desde la clase principal. Uno de los eventos más
importantes es el evento onItemSelected, el cual podrá mostrar una acción
cada vez que se seleccione un elemento de la lista, para poder hacer uso del
evento se hará de la misma manera que las lista.
Spinner1.setOnItemSelectedListener (
new AdapterView.OnItemSelectedListener() {
public void onItemSelected(AdapterView<?> parent,
android.view.View v, int position, long id) {
lbltexto.setText("Seleccionado: " + datos[position]);
}
public void onNothingSelected(AdapterView<?> parent) {

lbltexto.setText("");
}
});
En este caso el evento onItemSelected será llamado cada vez que se

seleccione o cambie de opción y cuando no se tenga ninguna opción
seleccionada se llamará al evento (onNothingSelected).
1. ¿Con cuántos tipos de layout cuenta Android Studio? Dar una breve
descripcion de cada uno de ellos.
2. ¿Para qué sirve el control ToggleButton?
3. ¿Para qué sirve el control ImageButton?
4. ¿Cuántos eventos acepta un Boton? Mencionar como mínimo 5 de ellos.
5. Mencionar 3 propiedades y dos eventos del control radioButton.
6. Mencionar 3 propiedades y dos eventos del control gridView.
7. Mencionar 5 propiedades y 2 eventos de un ListView.
8. El listView y el Spinner ¿Comparten las mismas propiedades o son
direfentes?

VI. CAPTURANDO Y MANEJANDO EVENTOS DE USUARIO.
OPERACIONES:
- Conocer y utilizar los tipos de eventosde Android.
ESCUCHADOR DE EVENTOS.
Un listener de un evento es una interfaz de la clase View que contiene un sólo
método callback. A continuación se mostrarán los eventos más comunes que
se utiliza en Android:
onClick()
Este evento es activado cuando el usuario a pulsado el control, cuando esto
sucede se llama a View.OnClickListener. También se puede decir que este
evento se activa cuando se cambia el foco de control y se presiona enter.
Private OnClickListener boton1= new OnClickListener() {

//procesos
}
};
onLongClick()
Este evento se activa cuando el usuario pulsa el item con las teclas de
navegación o con el trackball y pulsa la tecla "enter", este evento se llama
desde el View.OnLongClickListener.
onFocusChange()
Este evento se activa cuando el usuario está por encima del ítem, o cuando se
aleja. Este evento cuando es activado se llama desde
View.OnFocusChangeListener.
onKey()
Este evento se activa cuando el usuario esta con el foco sobre el control
deseado, este evento se llama desde View.OnKeyListener.

onTouch()
Este evento se activa cuando el usuario pulsa un control. A comparación de los
otros eventos este evento tiene múltiples estados ya que cuando uno pulsa un
control este evento detecta cuando uno ha pulsado el control, luego si se
mantiene pulsado o se mueve el control, cuando se deja de pulsar el control,
etc. Cuando se activa este control se llama desde el View.OnTouchListener.
MANEJADOR DE EVENTOS.
Adaptadores en Android (adapters).

Un adaptador no es más que una interfaz de datos que existe detrás de los
controles asociados a un adaptador. Existen muchos controles en Android que
necesitan una fuente de datos para mostrar sus valores como son el caso de
los Spinner, ListView entre otros. Esta fuente de datos se carga a través de un
adaptador ya que los controles accederán a este adaptador para tomar los
datos y mostrarlos en pantalla.
Los adaptadores más comunes son los siguientes:
- ArrayAdapter. Este adaptador provee de datos a un control de selección a

partir de un arreglo de datos de algún tipo sea entero, cadena o booleano.
- SimpleAdapter. El SimpleAdapta se usa para mapear datos que se
encuentren en diferentes controles.
- SimpleCursorAdapter. El simpleCursorAdapter es para mapear las columnas
de un cursor que venga de una base de datos y que la data se colocará en
algún control visual.
A continuación se verá cómo crear un adaptador de tipo ArrayAdapter para

trabajar con un array genérico de java:
final String[] elementos =

new String[]{"E1","E2","E3","E4","E5"};
ArrayAdapter<String> adap =
new ArrayAdapter<String>(this,
android.R.layout.simple_spinner_item, elementos);
Un caso en particular es cuando son controles estáticos se puede definir la lista

con posibles valores de tipo string-array, Para ello, primero se crearía un
nuevo fichero XML en la carpeta /res/values con el nombre valores_array.xml y
dentro del cual se colocan los valores seleccionables de la siguiente forma:

<?xml version="1.0" encoding="utf-8"?>

<resources>
<string-array name="Elementos">
<item>E1</item>
<item>E2</item>
<item>E3</item>
<item>E4</item>
<item>E5</item>
</string-array>
</resources>
Después de hacer este String-Array se crea el adaptador, para ello se utiliza un

método llamado createFromResource() para hacer referencia a este array XML
que se acaba de crear:
ArrayAdapter<CharSequence> adap =
ArrayAdapter.createFromResource(this,
R.array.Elementos,
android.R.layout.simple_spinner_item);
Pantalla táctil.
Todos los móviles (celulares y tablets) tienen una pantalla táctil que funciona
como dispositivos de entrada para las acciones que realizara el usuario del
móvil. El trabajar con la pantalla táctil hace que el uso del mouse sea sustituido
eliminados así el evento Click. Utilizando el touch de la pantalla táctil se puede
seleccionar, arrastrar y soltar cualquier elemento de la pantalla de forma
sencilla. Uno de los usos más importantes de la pantalla táctil es el de los
juegos ya que los juegos utilizan la pantalla táctil como fuente de ingreso de
acciones para los mismos; ya sean movimientos, disparos, saltos, etc. También
se utiliza la pantalla táctil para trabajar con los famosos Gestures, un muy buen
ejemplo del uso de estos gestures es el uso del patrón de ingreso en las
pantallas de inicio de los móviles.
Al usar la pantalla táctil del móvil se está llamando el método OnTouchEvent

en de una clase View (o implementar la interfaz OnTouchListener en otras
clases). El evento OnTouchEvent devuelve como parámetro la acción sobre la
pantalla, el evento que almacena la acción se llama MotionEvent.
A continuación se muestra la lista de acciones que puede almacenar el

MotionEvent:
- getAction(). Es el tipo de acción que devuelve el evento Touch.

- getX(), getY(). Muestra la posición de la pulsación.
- getDownTime(). Muestra el tiempo en ms se tocó por primera vez la
pantalla.
- getEventTime(). Muestra el tiempo en ms de la pulsación actual.

- getPressure(). Muestra la presión de la pulsación.

- getSize(). Muestra el grosor de la pulsación.
Crear un Layout con un textview el cual permita mostrar la acción

del touch cuando un dedo toque dicho control, o cuando se mueva
o cuando se levante el dedo.
1. Crear la vista del activity con un textview que diga evento touch.
2. Crear el programa en el src
public class MainActivity extends Activity implements OnTouchListener {

TextView txta;
@Override
txta=(TextView)findViewById(R.id.txt1);
txta.setOnTouchListener(this);
@Override
public boolean onTouch(View v, MotionEvent m) {
switch(m.getAction()){
case MotionEvent.ACTION_DOWN:
txta.setText("Has Activado el Evento Touch 1");
break;
case MotionEvent.ACTION_MOVE:
txta.setText("Has realizado un movimiento con el dedo 1");
break;
case MotionEvent.ACTION_UP:
txta.setText("Has retirado el dedo de la pantalla 1");
break;
}

return true;
}
}
Este ejercicio no necesita ningún diseño, sólo necesita la

programación en el src; por lo tanto, borrar el textView que
viene por defecto. Este ejercicio mostrará las coordenadas X y
Y conforme se va moviendo el dedo en la pantalla.

TextView textview1;
StringBuilder builder=new StringBuilder();
@Override
//eliminamos el setContentView ya que no necesitamos ningun layout
textview1=new TextView(this);
textview1.setText("Toca y Arrastra un dedo por favor!");
//colocamos el textview como setContentView
setContentView(textview1);
textview1.setOnTouchListener(new OnTouchListener() {
@Override
public boolean onTouch(View v, MotionEvent event) {
//inicializamos el builder en cero
builder.setLength(0);
switch(event.getAction()){
case MotionEvent.ACTION_DOWN:
builder.append("Presiono ");
break;
case MotionEvent.ACTION_MOVE:
builder.append("Moviendo ");
break;
case MotionEvent.ACTION_UP:
builder.append("Solto ");
break;
case MotionEvent.ACTION_CANCEL:
builder.append("Cancelo ");
break;
}
builder.append(event.getX()+" , "+event.getY());

String text=builder.toString();
textview1.setText(text);
return true;
}
});
}
}
La pantalla táctil con multiTouch.

El Multi-Touch es cuando el usuario del móvil mantiene varios dedos pulsados
a la misma vez, para esto se hace uso de indicadores e índices para poder
mantener el control de los dedos pulsados.
Pulsaciones.
Cuando el usuario pulsa con varios dedos la pantalla al mismo tiempo se
generan las siguientes acciones:
- ACTION_DOWN – Esa acción se dispara cuando el usuario toca por primera

la pantalla del móvil.
- ACTION_POINTER_DOWN – Este evento devuelve el índice del evento
mediante el evento getActionIndex.
- ACTION_MOVE – Cuando ocurre un cambio con respecto a los punteros del
mouse este evento se encarga de identificarlos.
- ACTION_POINTER_UP –Este evento se activa cuando se levanta un dedo
de la pantalla; por lo tanto, cambia la posición de los punteros.
- ACTION_UP –Se activa cuando el último dedo se ha levantado de la
pantalla.
Si se habla de multiTouch se tiene que hablar de dos cosas el índice y el ID:
- Índice: Almacena el indicador sobre cada indicar de una matriz. El índice de

un puntero es su posición dentro de esta matriz. La mayoría de
los MotionEvent métodos que utiliza para interactuar con los punteros tome
el índice de puntero como parámetro, no el ID puntero.
- ID: Cada puntero también tiene una asignación de ID que se mantiene
constante en todos los eventos táctiles para permitir el seguimiento de un
indicador individual a través de todo el gesto.
Como se obtiene la accione MotionEvent.

Para poder obtener la acción de MotionEvent se utiliza el método
getActionMasked() el cual permitirá recuperar la acción del MotionEvent . Si se
compara el evento getAction(), getActionMasked() este permite trabajar con

varios punteros. A continuación, puede utilizar getActionIndex() para devolver el

índice del puntero asociado a la acción.
A continuación se mostrará el ejemplo de cómo utilizar el motion event:
Int a = MotionEventCompat.getActionMasked (evento);

int i = MotionEventCompat.getActionIndex (evento);
xPos int = -1;
yPos int = -1;
Log.d (DEBUG_TAG, actionToString (acción));
if (event.getPointerCount ()> 1) {
Log.d (DEBUG_TAG, "El MultiTouch esta activado");
xPos = (int) MotionEventCompat.getX (evento, i);
yPos = (int) MotionEventCompat.getY (evento, i);
} Else {
Log.d (DEBUG_TAG, "evento touch simple");
xPos = (int) MotionEventCompat.getX (evento, el i);
yPos = (int) MotionEventCompat.getY (evento, el i);
}
actionToString static String público (int acción) {
switch (acción) {
caso MotionEvent.ACTION_DOWN: return "Down";
caso MotionEvent.ACTION_MOVE: return "Move";
caso MotionEvent.ACTION_POINTER_DOWN: return "Pointer Down";
caso MotionEvent.ACTION_UP: return "Up";
caso MotionEvent.ACTION_POINTER_UP: return "Pointer Up";
caso MotionEvent.ACTION_OUTSIDE: return "Outside";
caso MotionEvent.ACTION_CANCEL: return "Cancelar";
}
return "";
}
En este ejercicio se creará un cuadro de color verde con un

textView el cual permitirá colocar más de un dedo y conforme se
van colocando los dedos, el touch los va detectando y va
mostrando sus coordenadas en la parte inferior de la pantalla
fuera del cuadro verde

CREACIÓN DEL LAYOUT
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:id="@+id/LinearLayout2"
tools:context=".MainActivity" >
<TextView
android:id="@+id/TextViewEntrada"
android:layout_height="0dp"
android:layout_gravity="center"
android:layout_margin="2dp"
android:layout_weight="1"
android:background="@color/color5"
android:text="@string/titulo1"
android:textSize="10sp" />
<ScrollView
android:id="@+id/scrollView1"
android:layout_weight="1" >
<LinearLayout
android:orientation="vertical" >
<TextView
android:id="@+id/TextViewSalida"
android:layout_height="fill_parent"
android:text="@string/titulo2" />
</LinearLayout>
</ScrollView>
</LinearLayout>

PROGRAMACIÓN DEL SRC.
public class MainActivity extends Activity implements OnTouchListener {

@Override
TextView entrada = (TextView)findViewById(R.id.TextViewEntrada);
entrada.setOnTouchListener(this);
}
@Override
public boolean onTouch(View vista, MotionEvent evento) {
String acciones[] = { "ACTION_DOWN", "ACTION_UP",
"ACTION_MOVE", "ACTION_CANCEL","ACTION_OUTSIDE",
"ACTION_POINTER_DOWN", "ACTION_POINTER_UP"};
int accion = evento.getAction();
int codigoAccion = accion & MotionEvent.ACTION_MASK;
TextView salida = (TextView) findViewById(R.id.TextViewSalida);
salida.append(acciones[codigoAccion]);
for (int i = 0; i < evento.getPointerCount(); i++) {
salida.append(" puntero:" + evento.getPointerId(i) +
" x:" + evento.getX(i) + " y:" + evento.getY(i));
}
salida.append("\n");
return true; } }
1. Mencionar una breve descripcion del evento OnClick.

2. ¿Cuál es la diferencia entre el evento click y OnlOngClick?
3. Mencionar una breve descripcion del evento OnFocusChange.
4. ¿Cuál es la diferencia entre el evento OnClick y OnTouch?
5. ¿Qué es el MotionEvent?
6. Mencionar 5 acciones del Motion Event.
7. ¿Qué es el multitouch?
8. Mencionar 5 accione del MultiTocuh.
9. ¿Cuál es la diferencia entre índice y Id cuando se uitliza multitouch?

VII. INTENTS E INTENS FILTERS.
OPERACIONES:
- Crear aplicaciones con más de unapantalla.
- Trabajar con parámetros de envío entre pantallas.
DEFINICIÓN Y UTILIZACIÓN DE INTENTS PARA LANZAR ACTIVIDADES.
Los intents nos permiten llamar a otras pantallas que se encuentren dentro de
nuestra aplicación o incluso que estén fuera de nuestra aplicación, asi como
también nos permitirán enviar algún tipo de evento o algún tipo de dato a otra
aplicación
Las actividades se muestran de la siguiente manera:

public class MiActivity extends Activity {
@Override
public void onCreate(Bundle savedInstanceState) {
setContentView(R.layout.MiActivity);
}
}
Filtros en Intents.
Crear una aplicación que permita crear una lista de opciones. Cada una de las
opciones abrirá un nuevo intent y este a su vez tendrá un botón para retornar a
la lista principal.

1. Crear 4 nuevos layout en res/layout de nombre layout2, layout3, layout4,

layout5.
2. Crear 6 nuevas clase en el src de nombre actividad2, actividad3, actividad4,

actividad5, actividad6, actividad6 y le asignamos la estructura de una clase
android y la enlazamos con su layout respectivo (actividad2 con layout2 y así
sucesivamente).

// TODO Auto-generated method stub
setContentView(R.layout.actividad2);
}
3. Incluir todos los intent en el android manifest para que puedan ser
reconocidos por el proyecto.
4. Crear los diseños correspondientes a cada uno de los layout.
5. Declarar una lista por medio del xml ya que las lista es una clase que
android la tiene en sus librerías.
<ListView android:id="@id/android:list"

6. Programamos el codigo en el src principal.
public class MainActivity extends ListActivity {
private String[] opciones=new String[]

{"actividad2","actividad3","actividad4","actividad5","actividad6","actividad7"};
private ListView lista1=null;
private ListAdapter adap=null;

lista1=(ListView) findViewById(android.R.id.list);
adap=new
ArrayAdapter<String>(this,android.R.layout.simple_list_item_1,opciones
);
lista1.setAdapter(adap);
}
protected void onListItemClick(ListView l,View v,int position, long id){

super.onListItemClick(l, v, position, id);
String layouts=opciones[position];
try{
Class clazz=Class.forName("com.enati.c1_lista_intents."+layouts);
Intent intent=new Intent(this,clazz);
startActivity(intent);
}catch(ClassNotFoundException e){
e.printStackTrace();
} }
}
7. Programar el segundo layout con el botón para que vuelva al menú.
public class actividad2 extends Activity{
@Override
setContentView(R.layout.layout2);
Button btn2=(Button) findViewById(R.id.button1);

btn2.setOnClickListener(new Button.OnClickListener(){
@Override
public void onClick(View arg0) {
finish();
}
});
}

1. ¿Que es un Intent?
2. ¿Donde se declaran los intents al momento de ser creados?
3. Crear una aplicacion la cual cuente con dos pantalla, en la primera pantalla
que reciba tus datos de registro de usuarios y en la segunda pantalla que
muestre los datos ingresados

VIII. ANIMACIÓN Y DISEÑO DE MENÚS.
OPERACIONES:
- Conocer los diferentes tipos de menú que se pueden aplicar en una
aplicación Android
DEFINICIÓN DE UN MENÚ XML.
Si se quiere crear un menú XML este menú es almacenado dentro del

directorio RES, en la carpeta menú. Al igual que los layouts estos menús tienen
su propia carpeta.
Para definir un menú XML se tiene que crear un archivo XML dentro de la
carpeta menú que se encuentra en RES y debe comenzar por las etiquetas
<menú></menú> y dentro de dichas etiquetas se encontraran las etiquetas
<item></item> las cuales serán puestas para cada una de las opciones con las
que contara el menú.
Además, se puede anidar un menú dentro de otro colocando las etiquetas

<menú></menú> unas dentro de otras.
Creación de un menú de opciones.

Como se ha mencionado anteriormente para crear un menú se utiliza la palabra
reservada <menú></menú>. A continucion se muestra la creación de un menú
XML:

<menu xmlns:android="http://schemas.android.com/apk/res/android" >
<item android:id="@+id/MnuOpc1" android:title="Opcion1"
android:visible="true" android:enabled="true"></item>
<item android:id="@+id/MnuOpc2" android:title="Opcion2"></item>
<item android:id="@+id/MnuOpc3" android:title="Opcion3">
<menu>
<item android:id="@+id/SubMnuOpc1"
android:title="Opcion 3.1" />
</menu>

</item>
</menu>
Creación de menús contextuales y flotantes.

Crear una aplicación que permita mostrar un menú contextual con tres
opciones. La opción 3 mostrará un sub menú con dos opciones.
1. Crear un menu_principal.xml dentro de la carpeta res/menú que tenga la

siguiente estructura:

<menu xmlns:android="http://schemas.android.com/apk/res/android" >
<item android:id="@+id/MnuOpc1" android:title="Opcion1"

android:visible="true" android:enabled="true"></item>
<item android:id="@+id/MnuOpc2" android:title="Opcion2"></item>
<item android:id="@+id/MnuOpc3" android:title="Opcion3">
<menu>
</menu>
</item>
</menu>
2. Colocar en el layout principal un textview para que muestre un mensaje cada

vez que se clic en alguna opción del menú.
3. Crear la siguiente programación en el src:


TextView lblMensaje;
@Override
lblMensaje=(TextView) findViewById(R.id.lblMensaje);
}
@Override
inflater.inflate(R.menu.menu_principal, menu);
return true;
}
public boolean onOptionsItemSelected(MenuItem item) {

switch (item.getItemId()) {
case R.id.MnuOpc1:
lblMensaje.setText("Opcion 1");
return true;
case R.id.MnuOpc2:
return true;
case R.id.MnuOpc3:
return true;
case R.id.SubMnuOpc2:
lblMensaje.setText("Submenu 2");
return true;
default:
}
}
}

1. Crear la estructura XML de un menu como el siguiente:

MENU
Primera Opción
Opción 1.1
Opción 1.2
Segunda Opción
Tercera Opción
Opción 3.1
Opción 3.2
Cuarta Opción
Opción 4.1
Opción 4.2
Opción 4.3

IX. GEOLOCALIZACIÓN Y MAPAS.
OPERACIONES:
- Reconocer los diferentes tipos de sensores con los que cuenta el móvil.
- Utilizar la móvil como herramienta de ubicación mediante el GoogleMap.
LOCATIONMANAGER Y LOCATIONPROVIDER.
SENSORES DE POSICIÓN Y LOCALIZACIÓN.
Google Maps es una herramienta gratuita de google la cual se puede utilizar en

múltiples dispositivos y aplicaciones de diferentes tipos como es el caso de las
páginas web, los autoradios, los celulares, las tablets, etc. Google lanzo al
mercado esta herramienta el 8 de febrero del 2005 y en la actualidad puede ser
leída y utilizada por casi la mayoría de los navegadores web.
El uso de la localización en Android es un proceso que no requiere mucha

programación, lo que si requiere es una serie de pasos que nos llevarar a
conectar en servicio de mapas con nuestro dispositivo móvil.
Existen varias maneras de obtener la localización de nuestro móvil, aunque la

más usada es el uso de GPS, otra de las alternativas es hacer uso de las
antenas de telefonía móvil o a travez del acceso al wi-fi, cada uno de ellos tiene
una configuración distinta.
Mecanismos de localización.
Entre los principales mecanismos de localización tenemos los ya mencionados
GPS y Wi-fi pero existen otros mecanismos de localización como es el caso de
los métodos getAllProvaiders que pertenece a la clase LocationManager la cual
nos basaremos a la hora de utilizar la API de localización de android.

GEO CODIFICACIÓN.
La Geocodificación es cuando se le dan ciertas coordenadas geográficas a un

determinado mapa, es decir utilizamos lo que se le denomina altitud y latitud a
un determinado punto de mapas, están coordenadas son utilizadas por el móvil
para poder mostrar la ubicación de un determinado punto en el móvil.
MapView y MapController.
El control MapView permite manipular el mapa desde nuestra aplicación
instalada en el móvil. Este tipo de control es muy potente ya que nos permite
un control en vista satélite, marca las zonas disponibles, Mostrar información
sobre el trafico utilizando StreetView ,entre otros.
El MapController nos permite manipular el Zoom del mapa asi como otras
acciones del mapa mostrado por el control MapView
1. ¿Cuál es la direferecia entre LocationManager y locationProvaider?

2. ¿Que es Latitud y Altitud?
3. ¿Qué es el GPS?
4. ¿Cuál es la diferencia entre MapView y MapControler?
5. Crear una aplicacion la cual permite mostrar la ubicacion de senati,
utilizando el GPS para la ubicacion de donde te encuentres.

X. ALMACENAMIENTO Y RECUPERACION DE DATOS - SQLITE.
OPERACIONES:
- Crear una base de datos en SQLite.
- Crear un mantenimiento en Android Que permita interactuar con una BD en
SQLite.
¿QUÉ ES SQLITE? - CREACIÓN DE BD Y TABLAS.
SQLITE es una base de datos la cual permite la creación de base de datos

relacionales ocupando un tamaño muy pequeño en el dispositivo, este tipo de
base de datos son muy usadas ya que en la actualidad la mayoría de
aplicaciones para móviles requiere que la información sea almacenada y no lo
puede hacer con un administrador de base de datos grande sino que requiere
de una base de datos pequeña pero que soporte tablas relaciones.
En Android vienen incluidas las librerías necesarias para poder trabajar con
base de datos SQLite esto hace que el uso de esta BD sea bastante ligera ya
que se crea a través de una clase Java.
Para poder programar y usar la base de datos SQLite no se requiere de

ninguna librería adicional o administrador de base de datos ya que todos sus
comandos vienen incluidos en el mismo paquete de Android.
SQLITEOPENHELPER.
Para crear y trabajar con bases de datos en Android, es necesario hacer uso
de la clase SQLiteOpenHelper. En esta clase es necesario sobrescribir los
métodos onCreate() para crear la base de datos, y onUpgrade() para actualizar
la base de datos en caso de que existan cambios en el esquema de la misma.
Ambos métodos reciben como parámetro un objeto SQLiteDatabase.
SQLiteOpenHelper ofrece los métodos getReadableDatabase() y

getWriteableDatabase( para trabajar con un objeto SQLiteDatabase y poder
tener acceso de lectura y escritura sobre una base de datos.

SQLDATABASE Y CURSOR.
Cuando se utiliza la clase SQLiteDatabase esta provee los métodos insert(),
update() y delete() y execSQL() la cual permite ejecutar las sentencias SQL de
una manera más sencilla y de una forma más directa, y si se habla de esos
métodos que facilitan el uso del comando entonces también se habla de los
objetos ContentValues los cuales permiten definir claves y valores en las
sentencias Insert y Update. La clave (key) corresponde a la columna y el valor
es el valor para la columna.
Las consultas se pueden crear a través del método rawQuery() que acepta
como parámetro una sentencia en SQL o el método query() que proporciona
una interfaz para especificar los datos dinámicos o un objeto de
tipo SQLiteQueryBuilder. SQLiteBuilder es similar a la interfaz de un proveedor
de contenidos por lo que suele utilizarse con Content Providers. Hay que saber
también que toda consulta que se realice retornará un objeto de tipoCursor.
Preferencias – Content Provider.

Las preferencias en android con datos los cuales se almacenan en el móvil,
estos datos almacenados son personalizaciones, acciones, o pequeños datos
con respecto a una configuración o palabra clave requerida para las
configuraciones o acciones.
• MODE_PRIVATE. Sólo la aplicación en la que estas es la única que tiene

acceso. MODE_WORLD_READABLE. La aplicación en la que estas y otras
aplicaciones almacenadas en el equipo pueden acceder a estas
preferencias.
• MODE_WORLD_WRITABLE. Todas las aplicaciones que se encuentran en
el equipo pueden leer o realizar algún tipo de modificación a la preferencia.
Una vez que ya se ha declarado la preferencia se pueden usar sus comandos o

métodos get o put correspondientes al tipo de dato de cada preferencia.
Si lo que se quiere es modificar o agregar nuevas preferencias el proceso será

casi el mismo, con la diferencia que la modificación no se realizara
directamente sobre el elemento objetoSharedPreferences, sino que se hará
sobre su objeto de edición SharedPreferences.Editor. A este objeto
ingresaremos mediante la opción o método edit () de la
clase SharedPreferences.
Después de haber referenciado a sus respectivos métodos ya se pueden hacer

uso de los métodos put con su clave-valor, los métodos disponibles para
trabajar con las preferencias son putInt(), putFloat(), putBoolean(), etc.; una vez

actualizados/insertados todos los datos necesarios se llamará al

método commit() para confirmar los cambios.
¿Donde se almacenan estas preferencias compartidas?

Al usar preferencia estas no se almacenan en archivos binarios como es el
caso de las base de datos utilizando SQLite, sino que se crean ficheros XML
los cuales almacenaran la información de cada una de las preferencias. Estos
ficheros XML se almacenan en una ruta con el siguiente patrón:
/data/data/paquetejava/shared_prefs/nombre_coleccion.xml
Para el caso de nuestra preferencia se almacenaria de la siguiente manera:
/data/data/shared_prefs/pref1.xml
Crear una aplicación basada en preferencias que permite

ingresar un texto y modificar su tamaño mediante el control
seekBar. Dicha modificación se quedara grabada en la
aplicación. Para probar la aplicación cerrar y volver a abrir
la aplicación, el texto ingresado y el tamaño deben
permanecer tal y como quedo al momento que se cerró la
aplicación
1. Crear el diseño del siguiente layout.
android:layout_height="fill_parent" >
<SeekBar
android:id="@+id/barra"
<TextView
android:id="@+id/etiqueta"
android:text="@string/Ingreso" />
<EditText
android:id="@+id/caja"
android:ems="10"

android:inputType="textPersonName" >
<requestFocus />
</EditText>
<Button
android:id="@+id/boton"
android:text="@string/Boton" />
</LinearLayout>
2. Escribir el siguiente código en el SRC.
import android.os.Bundle;
import android.app.Activity;
import android.content.SharedPreferences;
import android.view.Menu;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.EditText;
import android.widget.SeekBar;
import android.widget.SeekBar.OnSeekBarChangeListener;
import android.widget.Toast;

//creamos le objeto de tipo seekbarra
SeekBar barra;
//creamos los objrtos de tipo boton y texto
EditText caja;
Button boton;
//creamos una variable de tipo preferencias que alamacenara todas las
preerncias
SharedPreferences npref;
String nompref="preferencias3";
private static final String TAM_FUENTE="tamFuente";

private static final String VALOR_TEXTO="valtexto";
@Override
boton=(Button) findViewById(R.id.boton);
caja=(EditText) findViewById(R.id.caja);
barra=(SeekBar) findViewById(R.id.barra);

boton.setOnClickListener(new OnClickListener() {
npref=getSharedPreferences(nompref, MODE_PRIVATE);
SharedPreferences.Editor editor=npref.edit();
editor.putFloat(TAM_FUENTE,caja.getTextSize());
editor.putString(VALOR_TEXTO,caja.getText().toString());
editor.commit();
Toast.makeText(getBaseContext(),"preferencias
almacenadas",Toast.LENGTH_SHORT).show();
}
});
npref=getSharedPreferences(nompref, MODE_PRIVATE);
float tamletra=npref.getFloat(TAM_FUENTE,12);
barra.setProgress((int)tamletra);
caja.setText(npref.getString(VALOR_TEXTO, ""));
caja.setTextSize(barra.getProgress());
barra.setOnSeekBarChangeListener(new OnSeekBarChangeListener() {
public void onStopTrackingTouch(SeekBar seekBar) {
}
public void onStartTrackingTouch(SeekBar seekBar) {
}
public void onProgressChanged(SeekBar seekBar, int progress,
boolean fromUser) {
caja.setTextSize(progress);
}
});
@Override
getMenuInflater().inflate(R.menu.activity_main, menu);
return true;
}
}

CONTENT PROVIDERS.
El uso de Content Provaider permite la comunicación entre distintas

aplicaciones. Al igual que para las bases de SQLite para los Content Providers
deberemos crear una clase que herede de ContentProvider y declararla en el
manifest.
El uso de lso content provaiders son una excelente opción ya que solo basta un
buen uso de los URIS y de sus libriras de código.
Conexiones y Mantenimiento de Datos (Insert - Delete - Update).

Se creara una agenda SQLite que le permita al usuario agregar contactos con
su dirección y teléfono en una base de datos Local. Para ello necesitaremos
una actividades, que desplegará los elementos que se encuentren
almacenados en la base de datos y también donde creará nuevas tareas. Esta
actividad va a interactuar por medio del uso de Intents.
1. Crear un nuevo proyecto llamado Bd_Contactos.

2. Luego, crear un nuevo paquete para guardar la clase que manejará la base
de datos para el caso del ejemplo el paquete llamado
com.senati.bd_contactos. Dentro del paquete se ha creado una clase
llamada Handler_Sqlite.java tal y como se muestro a continuación:
3. Pasar a ver el código que deberá contener la clase Handler_Sqlite.java

agregando primero las sentencias import con las clases que se necesitan:
import android.content.ContentValues;
import android.content.Context;
import android.database.Cursor;
import android.database.SQLException;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteDatabase.CursorFactory;
import android.database.sqlite.SQLiteOpenHelper;
public class Handler_Sqlite extends SQLiteOpenHelper{

public static final String _ID = "_id";

public static final String NOMBRE = "NOMBRE";
public static final String DIRECCION = "DIRECCION";
public static final String CORREO = "CORREO";
public static final String TELEFONO= "TELEFONO";
public Handler_Sqlite(Context context, String name, CursorFactory factory,
int version) {
super(context, name, factory, version);
}
@Override
public void onCreate(SQLiteDatabase db) {
String query="CREATE TABLE contactos("+_ID+" INTEGER PRIMARY
KEY AUTOINCREMENT, NOMBRE TEXT, DIRECCION TEXT, CORREO TEXT,
TELEFONO TEXT);";
db.execSQL(query);
}
@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
db.execSQL("DROP TABLE IF EXISTS contactos");
onCreate(db);
}
public void insertarReg(String nom, String dir, String cor, String tel){
ContentValues valores=new ContentValues();

valores.put ("NOMBRE", nom);
valores.put ("DIRECCION", dir);
valores.put ("CORREO", cor);
valores.put ("TELEFONO", tel);
this.getWritableDatabase().insert("contactos", null, valores);
}
public void EliminarReg(int cod){
this.getWritableDatabase().delete("contactos",_ID+"="+cod , null);
}
public void abrir(){

this.getWritableDatabase();
}
public void cerrar(){

this.close();
}

public Cursor listaContactos(){

Cursor micursor=this.getReadableDatabase().query("contactos",new
String[]{_ID,NOMBRE,DIRECCION,CORREO,TELEFONO},null,null, null, null, null);
if(micursor!=null){
micursor.moveToFirst();
System.out.println("resultado");
System.out.println(micursor.getCount());
}else{
System.out.println("nancy");
}
return micursor;
}
public Cursor ListarxNombre(String inputText) throws SQLException {
Cursor mCursor = null;
if (inputText == null || inputText.length() == 0) {
mCursor = this.getReadableDatabase().query("contactos",new
String[]{_ID,NOMBRE,DIRECCION,CORREO,TELEFONO},null,null, null, null, null);
} else {
mCursor =this.getReadableDatabase().query("contactos",new
String[]{_ID,NOMBRE,DIRECCION,CORREO,TELEFONO},NOM
BRE + " like '%" + inputText + "%'",null, null, null, null);
}
if (mCursor != null) {
mCursor.moveToFirst();
}
return mCursor;
}
}
Esta clase permite definir la estructura de la base de datos.
El método onCreate () es el que ejecuta la consulta CREATE para la base de

dato y el método onUpgrade () manejaremos todas las acciones que
necesitemos cada vez que se actualice la base de datos; en este caso,
únicamente estamos mandando mensajes en el Log.

DISEÑO DEL PRIMER LAYOUT.
4. Definir 5 archivos de layout, el primero que es el principal para agregar los

datos del contacto a grabar, dos para mostrar la lista de los contactos
mediante el objeto listview, uno para eliminar los contactos y uno para editar
los contactos.
CÓDIGO DE LA PANTALLA PRINCIPAL(ACTIVITY_MAIN.XML)
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" >
<LinearLayout
<TextView
android:layout_gravity="center_horizontal"
android:text="Contactos"
android:textAppearance="?android:attr/textAppearanceMedium" />
</LinearLayout>
<TableLayout
android:layout_height="wrap_content" >
<TableRow
android:id="@+id/tableRow1"
<TextView
android:id="@+id/txtcod"
android:text="Nombre:" />
<EditText
android:id="@+id/txtnom"
android:ems="10"
<requestFocus />
</EditText>
</TableRow>
<TableRow
<TextView
android:id="@+id/txtnom2"
android:text="Direccion: " />
<EditText

android:id="@+id/txtdir"
android:ems="10"
android:inputType="textPersonName" />
</TableRow>
<TableRow
<TextView
android:id="@+id/txtdireccion2"
android:text="Correo: " />
<EditText
android:id="@+id/txtcorreo"
android:ems="10"
android:inputType="textEmailAddress" />
</TableRow>
<TableRow
<TextView
android:id="@+id/txtcorreo2"
android:text="Telefono: " />
<EditText
android:id="@+id/txttel"
android:ems="10"
android:inputType="phone" />
</TableRow>
</TableLayout>
<Button
android:id="@+id/btngrabar"
android:text="Grabar Contacto" />
<TableRow

<Button
android:id="@+id/btnmostrar"
android:text="Mostrar Contactos" />
</TableRow>
<TableRow
<Button
android:id="@+id/btneliminar"
android:layout_width="140dp"
android:text="Eliminar" />
<Button
android:id="@+id/btneditar"
android:text="Editar" />
</TableRow>
</LinearLayout>
Codigo de la lista de contactos (listado_principal.xml)


<TextView
android:layout_gravity="center_horizontal"
android:text="Listado de Contactos"
android:textAppearance="?android:attr/textAppearanceMedium" />
<EditText
android:id="@+id/txtcontacto"
android:ems="10"
<requestFocus />
</EditText>
<ListView
android:id="@+id/listView1"
</ListView>
</LinearLayout>
Codigo de la lista (listado.xml)

android: layout_width="match_parent"
android: layout_height="match_parent"
<LinearLayout
android: layout_width="match_parent"
android: layout_height="wrap_content"
android: orientation="vertical" >
<LinearLayout
<TextView
android: id="@+id/textView1"
android: layout_width="80dp"
android: layout_height="wrap_content"
android: text="Codigo:" />
<TextView
android:id="@+id/txtcod"
android:layout_marginLeft="38dp"
android:text="TextView" />
</LinearLayout>
</LinearLayout>
<LinearLayout
<LinearLayout
<TextView
android:text="Nombre:" />
<TextView
</LinearLayout>
</LinearLayout>
<LinearLayout

<LinearLayout
<TextView
android:text="Direccion: " />
<TextView
android:id="@+id/txtdireccion2"
</LinearLayout>
</LinearLayout>
<LinearLayout
<LinearLayout
<TextView
android:text="Correo:" />
<TextView
android:id="@+id/txtcorreo2"
</LinearLayout>
</LinearLayout>
<LinearLayout
<LinearLayout
<TextView

android:text="Telefono" />
<TextView
android:id="@+id/txttelefono2"
</LinearLayout>
</LinearLayout>
</LinearLayout>
Código de la actividad eliminar (activity_elliminar.xml)

<TextView
android:text="Ingrese Codigo a Eliminar:" />
<EditText
android:id="@+id/txtcodeliminar"
android:ems="10"
<requestFocus />
</EditText>

<Button
android:id="@+id/botoneliminar2"
android:text="Eliminar Registro" />
</LinearLayout>
Código de la actividad editar (activity_editar.xml)

<TextView
android:text="Editar Contacto" />
<LinearLayout
<LinearLayout
<TextView

android:text="Codigo" />
<EditText
android:id="@+id/txtcod3"
android:ems="10"
<requestFocus />
</EditText>
</LinearLayout>
</LinearLayout>
<LinearLayout
<LinearLayout
<TextView
android:text="Nombre" />
<EditText
android:ems="10"
</LinearLayout>
</LinearLayout>
<LinearLayout
<LinearLayout
<TextView
android:text="Direccion" />

<EditText
android:id="@+id/txtdir3"
android:ems="10"
</LinearLayout>
</LinearLayout>
<LinearLayout
<LinearLayout
<TextView
android:text="Correo" />
<EditText
android:id="@+id/txtcor3"
android:ems="10"
</LinearLayout>
</LinearLayout>
<LinearLayout
<LinearLayout
<TextView
android:text="Telefono" />
<EditText
android:id="@+id/txttel3"

android:ems="10"
</LinearLayout>
</LinearLayout>
<Button
android:id="@+id/btneditar2"
android:text="Editar Datos" />
</LinearLayout>
5. Ahora que ya se han definido los recursos, layouts y las clases que
ayudarán a manipular la parte de SQLite en Android. Estamos listos para
crear las actividades que nos ayudarán a juntar cada una de estas piezas.
1. Dentro del directorio principal de src del proyecto vamos a crear las
siguientes actividades:
El MainActivity.Java corresponde a la clase principal la que nos permite

agregar los contactos a la bd, luego tenemos MainActivity_listado.java que
mostrara los registros guardados en la bd, Mainactivity_Editar.java que
permitirá editar los datos de la bd y MainActivity_Eliminar.java que permitirá
eliminar los registros de la bd y mostramos a continuación:
Mainactivity.java
import com.senati.bd_contactos.database.Handler_Sqlite;
import android.content.Intent;
import android.widget.TextView;

@Override
final Handler_Sqlite helper=new Handler_Sqlite(this, "Bd1", null, 1);

//BOTON GRABAR
Button btngrabar=(Button) findViewById(R.id.btngrabar);
btngrabar.setOnClickListener(new Button.OnClickListener(){
@Override
public void onClick(View arg0) {
TextView nom=(TextView) findViewById(R.id.txtnom);
TextView dir=(TextView) findViewById(R.id.txtdir);
TextView correo=(TextView) findViewById(R.id.txtcorreo);
TextView tel=(TextView) findViewById(R.id.txttel);
String nom2=String.valueOf(nom.getText());
String dir2=String.valueOf(dir.getText());
String cor2=String.valueOf(correo.getText());
String tel2=String.valueOf(tel.getText());
helper.abrir();
helper.insertarReg(nom2, dir2, cor2, tel2);
helper.cerrar();
nom.setText("");
dir.setText("");
correo.setText("");
tel.setText("");
nom.findFocus();
Toast msg=Toast.makeText(getApplicationContext(),"Se
grabo ah "+nom2,Toast.LENGTH_LONG);
msg.show();
}
});
//BOTON MOSTRAR
Button btnmostrar=(Button) findViewById(R.id.btnmostrar);
btnmostrar.setOnClickListener(new Button.OnClickListener(){
@Override
Intent i = new Intent (getApplicationContext(),
MainActivity_listado.class);
//estas sentencia indica que la actividad principal espera un resultado
startActivity(i);
}
});

//BOTON ELIMINAR
Button btneliminar=(Button) findViewById(R.id.btneliminar);
btneliminar.setOnClickListener(new Button.OnClickListener(){
@Override
Intent i = new Intent (getApplicationContext(), MainActivity_Eliminar.class);
startActivity(i);
});
//BOTON EDITAR
Button btneditar=(Button) findViewById(R.id.btneditar);
btneditar.setOnClickListener(new Button.OnClickListener(){
@Override
Intent i = new Intent (getApplicationContext(),
MainActivity_listado.class); //estas sentencia indica que la actividad principal
espera un resultado
startActivity(i);
}
});
}
}
Mainactivity_listado.java
package com.senati.bd_contactos;
import android.content.Intent;
import android.provider.SyncStateContract.Helpers;
import android.text.Editable;
import android.text.TextWatcher;
import android.widget.AdapterView;
import android.widget.AdapterView.OnItemClickListener;
import android.widget.FilterQueryProvider;
import android.widget.ListView;
import android.widget.SimpleCursorAdapter;
public class MainActivity_listado extends Activity {

//instanciamos la base de datos


//creamos un cursor que permite recorrer y recuperar los registros
SimpleCursorAdapter dataAdapter;
//creamos un objeto de tipo listview
ListView lv;
@Override
setContentView(R.layout.listado_principal);
//llamamos a la función cargar contactos creada mas abajo
cargarContactos();
//creamos el objeto de tipo edittext y lo referenciamos a la caja de texto
EditText texto=(EditText) findViewById(R.id.txtcontacto);
//creamos un evento para la caja de texto
texto.addTextChangedListener(new TextWatcher() {
//cuando cambie el texto
@Override
public void onTextChanged(CharSequence s, int start, int before, int count) {
// le agregamos la condicion de busqueda
dataAdapter.getFilter().filter(s.toString());
}
//antes de que cambie el texto
@Override
public void beforeTextChanged(CharSequence s, int start, int
count,
int after) {
}
//despues de que cambie el texto
@Override
public void afterTextChanged(Editable s) {
}
});
//aplicamos un criterio de busqueda
//este metodo genera una especie de consulta con un criterio de consulta
//el metodo filter obliga a disprarar este metodo
dataAdapter.setFilterQueryProvider(new FilterQueryProvider() {
@Override
public Cursor runQuery(CharSequence constraint) {
return helper.ListarxNombre(constraint.toString());
}
});
//Activamos el clic dl listado para que capture el codigo y lo envie al otro layout
lv=(ListView) findViewById(R.id.listView1);

lv.setOnItemClickListener(new OnItemClickListener(){
@Override
public void onItemClick(AdapterView<?> arg0, View arg1, int position,long
arg3){
//recuperamos el item que esta en tal posicion
Cursor xcursor=(Cursor) lv.getItemAtPosition(position);
//este metodo hace que recupere este valor o devuelve una
excepcion
String cod=xcursor.getString(xcursor.getColumnIndexOrThrow("_id"));
//Toast.makeText(getApplicationContext(),cod,Toast.LENGTH_LONG).show();
//Ahora enviamos el valor capturado a mainactivity_editar
Intent i = new Intent (getApplicationContext(), MainActivity_Editar.class);
i.putExtra("clave", cod);
startActivity(i);
}
});
}
private void cargarContactos(){
//helper.abrir();
try{
Cursor cursor=helper.listaContactos();
//colocamos el nombre de las columnas que va a air al listview
//el nombre de las columnas estan en countriesdbadapter
String[]
columnas={Handler_Sqlite._ID,Handler_Sqlite.NOMBRE,Handler_Sqlite.DIRECCION,
Handler_Sqlite.CORREO,Handler_Sqlite.TELEFONO};
//colocamos los valores de cada columna donde se van a pintar
int[]
donde={R.id.txtcod,R.id.txtnom2,R.id.txtdireccion2,R.id.txtcorreo2,R.id.txttelefono2};
//ahora seleccionamos el adaptador que vamos a utilizar para mostrar los
valores
dataAdapter=new SimpleCursorAdapter(this,R.layout.listado, cursor, columnas,
donde);
lv=(ListView) findViewById(R.id.listView1);
lv.setAdapter(dataAdapter);
}catch(Exception e){System.out.println(e);}
}
}
Mainactivity_eliminar.java

public class MainActivity_Eliminar extends Activity {

@Override
setContentView(R.layout.activity_eliminar);
Button btneliminar2=(Button) findViewById(R.id.botoneliminar2);
btneliminar2.setOnClickListener(new Button.OnClickListener(){
@Override
TextView cod=(TextView)
findViewById(R.id.txtcodeliminar);
int cod2=Integer.parseInt(String.valueOf(cod.getText()));
helper.abrir();
helper.EliminarReg(cod2);
helper.cerrar();
cod.setText("");
Toast msg=Toast.makeText(getApplicationContext(),"Se Elimino el
Registro "+cod2,Toast.LENGTH_LONG);
msg.show();
}
});
}
}
Mainactivity_editar.java
import android.widget.ListView;
import android.widget.SimpleCursorAdapter;
public class MainActivity_Editar extends Activity {
//declaramos la variable que almacenara el codigo enviado
String codrecuperado="";
@Override
setContentView(R.layout.activity_editar);
//instanciamos la base de datos

//recuperamos el valor enviado

Bundle recupera=getIntent().getExtras();
if(recupera!=null){
codrecuperado=recupera.getString("clave");
}
//declaramos todos los textbox
TextView cod3=(TextView) findViewById(R.id.txtcod3);
TextView nom3=(TextView) findViewById(R.id.txtnom3);
TextView dir3=(TextView) findViewById(R.id.txtdir3);
TextView cor3=(TextView) findViewById(R.id.txtcor3);
TextView tel3=(TextView) findViewById(R.id.txttel3);
cod3.setText(codrecuperado);
int codenviado=Integer.parseInt(codrecuperado.toString());
Cursor cursor=helper.ListarxCod(codenviado);
nom3.setText(cursor.getString(cursor.getColumnIndex(helper.NOMBRE)));
dir3.setText(cursor.getString(cursor.getColumnIndex(helper.DIRECCION)));
cor3.setText(cursor.getString(cursor.getColumnIndex(helper.CORREO)));
tel3.setText(cursor.getString(cursor.getColumnIndex(helper.TELEFONO)));
}
}
ARCHIVOS LOCALES.
Android permite almacenar cierta información en archivos de texto (extensión

txt), este tipo de almacenamiento se le conoce como archivos planos,
generalmente se utilizan estos archivos planos para guardar información que
no sea muy extensa pero si importante como para ser almacenada. El acceso a
estos archivos es parecido al de Java estándar, se deben crear tanto input
stream como output stream. Puede soportar solamente archivos creados en la
carpeta de la aplicación. Por lo que se necesita saber dónde están
almacenadas las aplicaciones. Están almacenadas en:
/data/data/nombre_paquete/files/nombre_fichero
En las últimas versiones de Android estos archivos de textos también pueden

ser guardados en la SDCARD. Es importante ser conscientes de que algunos
dispositivos tienen una memoria interna limitada, por lo que no debe exigir
demasiado con el espacio de almacenamiento de estos archivos.

Modos de acceso:
Si estamos hablando de archivos planos o archivos de tipo txt tenemos que
hablar de los diferentes tipos de acceso. A continuación mostramos los
diferentes tipos de acceso:
- MODE_PRIVATE. Acceso sólo desde la aplicación.

- MODE_APPEND. Este método se utiliza para añadir datos a un archivo que
ya ha sido almacenado con anterioridad.
- MODE_WORLD_READABLE. Permite el acceso al archivo desde otras
aplicaciones.
- MODE_WORLD_WRITABLE. Permite el acceso y escritura desde otras
aplicaciones.
Se creará una aplicación la cual permita guardar un texto en la

memoria interna del móvil y lo pueda recuperar mediante un
botón.
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;

import android.view.View.OnClickListener;
public class MainActivity extends Activity{

EditText caja;
Button bsave,bload;
FileInputStream fIn;
FileOutputStream fout;
private static final int TAM_BLOQUE=100;
@Override
caja=(EditText) findViewById(R.id.texto);
bsave=(Button) findViewById(R.id.boton1);
bload=(Button) findViewById(R.id.boton2);
bsave.setOnClickListener(new OnClickListener() {
@Override
String str=caja.getText().toString();
try{
fout=openFileOutput("archivotexto.txt",MODE_WORLD_READABLE);
OutputStreamWriter osw=new OutputStreamWriter(fout);
osw.write(str);
osw.flush();
osw.close();
Toast.makeText(getBaseContext(),"Datos Guardados con exito",
Toast.LENGTH_SHORT). show();
caja.setText("");
}catch(Exception e){
}
}
});
bload.setOnClickListener(new OnClickListener() {
@Override
try{
fIn=openFileInput("archivotexto.txt");
InputStreamReader isr=new InputStreamReader(fIn);

char[] inputBuffer=new char[TAM_BLOQUE];

String s="";
int cleido;
while((cleido=isr.read(inputBuffer))>0){
String lectura=String.copyValueOf(inputBuffer,0,cleido);
s+=lectura;
inputBuffer=new char[TAM_BLOQUE];
}
caja.setText(s);
}catch(Exception e){
} }
});
}
}
ALMACENAMIENTO DE ARCHIVOS EN LA MEMORIA EXTERNA.
Otra opción de almacenamiento de archivos es el uso de la memoria externa,

que generalmente será una tarjeta de memoria SD. Es importante destacar que
en el caso de la memoria externa esta puede estar disponible o no según sea
el caso, caso contrario sucede con la memoria interna del móvil que siempre se
mantendrá presente. Si lo que se desea es crear una aplicación haciendo uso
de esta memoria lo recomendable seria primero cerciorarse si es que la
memoria externa era activa o no.
Cuando se quiera leer o escribir en un archivo externo se utilizara el comando

MEDIA_MOUNTED el cual nos permite escribir en los archivos y si lo que
queremos es leer utilizaremos el comando MEDIA_MOUNTED_READ_ONLY
que nos dice que está disponible con permisos de solo lectura.
Este ejercicio permitirá almacenar archivos en la memoria externa

del móvil. Para este caso se está almacenando una canción en un
pequeño archivo de texto.

1. Crear una carpeta llamada canciones dentro de la carpeta asset y en ella

guardar un archivo de tipo txt conteniendon un texto.
2. Codificar las siguientes líneas:
package com.idat.almacenamiento_externo;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import android.content.res.AssetManager;

@Override
TextView texto;
texto=(TextView) findViewById(R.id.texto);
AssetManager assetManager=getAssets();
InputStream inputStream=null;
try{
inputStream = assetManager.open("canciones/musica.txt");

String text=cargararchivotexto(inputStream);
texto.setText(text);
}catch(IOException e){
texto.setText("No se úede cargar el archivo");
}finally{
if(inputStream!=null)
try{
inputStream.close();
}catch (Exception e2) {
texto.setText("No se puede cerra el archivo");
} }
}
public String cargararchivotexto(InputStream inputStream) throws IOException{

ByteArrayOutputStream byteStream=new ByteArrayOutputStream();
byte[]bytes=new byte[4096];
int len=0;
while((len=inputStream.read(bytes))>0)
byteStream.write(bytes,0,len);
return new String(byteStream.toByteArray(),"UTF8");
}
}
1. ¿Qué es SQLite?
2. ¿Cuáles son las ventajas de utilizar SQLite?
3. ¿Para qué sirve el SQLITEOPENHELPER?
4. ¿Para qué sirve un cursor?
5. ¿Qué es un Content provider?
6. ¿En qué se diferencia Mode_World_Mode_World_ y Mode_World_writiable?
7. ¿Dónde se almacenan las preferencias compartidas?
8. ¿Dónde se almacena un archivo local?
9. ¿Cuáles son los modos de acceso de un archivo local, de una breve
descripcion de cada uno de ellos?

XI. SERVICIOS DE RED.
OPERACIONES:
- Conocer y aplicar los diferentes tipos de Web Service que existen en un
proyecto Android.
WEB SERVICE
Un web service es un conjunto de protocolos y estándares que permiten

intercambiar información entre programas y aplicaciones que no han sido
creados bajo un mismo lenguaje de programación, es decir pueden ser
ejecutadas en cualquier plataforma, pueden utilizar los servicios web para
intercambiar datos en redes de ordenadores como Internet, esto significa que
los ws aportan interoperabilidad.
La operabildiad se realiza mendiante estándares abiertos. Uno de los

estándares más conocidos u usados está basado en el estándar abierto
SOPAS (Simple Access Object Protocol) o también el conocido XML-RPC.
SOAP permite la comunicación entre diferentes aplicaciones gracias al

intercambio de datos mediante los archivos XML.

CREACIÓN DE UN SERVICIO WEB USANDO SOAP.
Crear una aplicación la cual permite conectarse a una página web para que
pueda realizar el cambio de grados Fahrenheit a Celsius, devolviendo le valor
de respuesta.
1. Crear el proyecto y agregar la librería.

2. Crear el siguiente layout:

android:layout_height="fill_parent"
>
<TextView
android:text="Fahrenheit: "
/>
<EditText
android:id="@+id/inputTemp"
android:inputType="numberSigned"
android:background="@android:drawable/editbox_background"
/>
<Button

android:text="Convert"
android:id="@+id/convert"
android:onClick="convertFahrenheitToCelsius"
/>
<TextView
android:id="@+id/response"
android:gravity="center_horizontal"
/>
</LinearLayout>
3. Codificar la actividad:
import org.ksoap2.SoapEnvelope;
import org.ksoap2.serialization.PropertyInfo;
import org.ksoap2.serialization.SoapObject;
import org.ksoap2.serialization.SoapPrimitive;
import org.ksoap2.serialization.SoapSerializationEnvelope;
import org.ksoap2.transport.HttpTransportSE;
import com.webservice.test.R.id;
public class WSMain extends Activity {
private final String NAMESPACE = "http://tempuri.org/";

private final String
URL="http://www.w3schools.com/webservices/tempconvert.asmx";
private final String SOAPACTION = "http://tempuri.org/FahrenheitToCelsius";
private final String METHOD = "FahrenheitToCelsius";
@Override
setContentView(R.layout.main);
}
public void convertFahrenheitToCelsius(View v)

{
TextView response_tv = (TextView)findViewById(id.response);
final TextView input_tv = (TextView)findViewById(id.inputTemp);
String fahrenheit_value = input_tv.getText().toString();
if(fahrenheit_value == null || fahrenheit_value.length() == 0)
{
response_tv.setText("Error!");
return;
}
SoapObject request = new SoapObject(NAMESPACE, METHOD);
PropertyInfo FahrenheitProp = new PropertyInfo();
FahrenheitProp.setName("Fahrenheit");
FahrenheitProp.setValue(fahrenheit_value);
FahrenheitProp.setType(String.class);
request.addProperty(FahrenheitProp);
SoapSerializationEnvelope envelope = new SoapSerializationEnvelope
(SoapEnvelope.VER11);
envelope.dotNet = true;
envelope.setOutputSoapObject(request);
HttpTransportSE androidHttpTransport = new HttpTransportSE(URL);
try
{
androidHttpTransport.call(SOAPACTION, envelope);
SoapPrimitive response = (SoapPrimitive)envelope.getResponse();
response_tv.setText(fahrenheit_value + " F = " + response.toString() + " C");
}catch(Exception e)
{
}
}
}
Conexión HTTP.
Todas las conexiones realizadas desde un móvil hacia un servidor web tienen
un estándar a nivel mundial el cual lleva el nombre de Hipertext Transfer
Protocol HTTP. Este protoclo nos permite la comunicación y transferencia de
datos de una manera rápida y sencilla entre equipos que pertenecen a una
determinada red.
Al móvil el cual realiza alguna petición de algún tipo de dato se le llama cliente
y a aquel que contiene la data o el sitio de almacenamiento se le denomina
servidor.

Para realizar una petición hacia el servidor esta usa dos de los métodos mas
conocidos para el envio de datos, estos métodos son los métodos GET y SET,
se podrá usar cualquiera de estos desde el móvil, eso se hace al momento de
realizar la codificación.
La diferencia entre estos dos métodos es que el método GET es un método

publico es decir todo pueden ver los datos que se envían ya que se muestran
en el URL, por ejemplo cuando se hace una búsqueda en google, pero cuando
el usuario no desea que los datos se vean en la url entonces se envía los
datos mediante el método POST, como es el caso de cuando te logueas, ya
que los datos de tu password no deben de verse.
1. ¿Qué es un Web Service?

2. ¿Cuántos tipos de Web Services existen? Mencionar 3 como mínimo y dar
una breve descripción.
3. ¿Qué significa SOAP?
4. Mencionar 3 ventajas de utilizar SOAP.
5. Para qué me sirve una conexion HTTP.

XII. SERVICIOS WEB ANDROID CON PHP.
OPERACIONES:
- Crear un servicio mediante PHP que permita la conexión de Android con
MySQL.
- Realizar un mantenimiento de datos desde Android a una Bd en MySQL.
- Wamp Server instalado.
- Mysql-Front instalado.
- NetBeans Instalado.
PETICIONES GET Y POST DESDE ANDROID UTILIZANDO OBJETOS

JSONOBJECT – JSONARRAY.
El uso de los Web Service han permitido la comunicación entre diferentes

aplicaciones, pero también el uso de esta tecnología ha hecho que cada día
crezca cada vez más la trasferencia de datos entre las aplicaciones, para ello
ha surgido un nuevo formato para el intercambio de datos en cual se llama
JSON, este formato permite el intercambio de datos más ligeros.
Realizar consulta de datos

Como ya se anotado un Web Service o Servicio Web es una aplicación que
permite la comunicación entre distintas aplicaciones que han sido creadas a
través de diferentes lenguajes de programación. Comúnmente hemos utilizado
la librería SOAP, que trabaja utilizando XML o JSON.
Una excelente opción es crear su propio servicio web igualmente basado en

XML y objetos de tipo JASON utilizando programas como PHP, JSP, ASP o
algún otro lenguaje de programación.
Se creará un web service echo en php el cual permita almacenar datos desde
un dispositivo con Android hacia una base de datos MySql, a su vez permite
leer, insertar, eliminar y editar datos desde el móvil hacia la base de datos
MySql, haciendo uso de PHP como intermediario.

1. Agregar al proyecto los permisos de internet ya que se necesitará de ese

permiso para salir desde la aplicación móvil hacia la aplicación web.
2. Crear la estructura del proyecto PHP el cual servirá como servicio WEB.

IngresoData.php
<?php
$nom=$_REQUEST['nombre'];
$edad=$_REQUEST['edad'];
$sexo=$_REQUEST['sexo'];
$cnx=new PDO("mysql:host=localhost;dbname=android2","root","");
$res=$cnx->query("insert into usuarios values(null,'$nom','$edad','$sexo')");
echo $nom."<br>".$edad."<br>".$sexo;
?>
GetData.php
<?php
$res=$cnx->query("select * from usuarios");
$datos=array();
foreach($res as $row){
$datos[]=$row;
}
echo json_encode($datos);
?>
eliminarData.php
<?php
$cod=$_REQUEST['cod'];

$res=$cnx->query("delete from usuarios where codUSU='$cod'");
?>
3. Realizar el diseño de pantallas.
4. Programar las clases.
MAINACTIVITY.JAVA

EditText txtNom,txtEdad,txtSexo;
Button btnInsertar,btnListar,btnEliminar;
@Override
txtNom=(EditText) findViewById(R.id.txtNom);
txtEdad=(EditText) findViewById(R.id.txtEdad);
txtSexo=(EditText) findViewById(R.id.txtSexo);
btnInsertar=(Button) findViewById(R.id.btnAgregar);
btnInsertar.setOnClickListener(new OnClickListener() {
@Override
Thread nt=new Thread(){
@Override
public void run() {
try{
final String res;
res=enviarGet(txtNom.getText().toString(),txtEdad.getText().toString(),txtSexo.g
etText().toString());
runOnUiThread(new Runnable() {
public void run() {
Toast.makeText(MainActivity.this, res,
Toast.LENGTH_LONG).show();
}
});
}catch(Exception e){}
}
};
nt.start();
}
});
btnEliminar=(Button) findViewById(R.id.btnEliminar);
btnEliminar.setOnClickListener(new OnClickListener() {
@Override
Intent i=new
Intent(getApplicationContext(),eliminarCod.class);
startActivity(i);
}
});
btnListar=(Button) findViewById(R.id.btnListar);
btnListar.setOnClickListener(new OnClickListener() {

@Override
Intent i=new Intent(getApplicationContext(),Listado.class);
startActivity(i);
}
});
}
public String enviarGet(String n, String e, String s){

HttpClient httpClient=new DefaultHttpClient();
HttpContext localContext=new BasicHttpContext();
HttpResponse response=null;
String parametros="?&nombre="+n+"&edad="+e+"&sexo="+s;
HttpGet httpget=new
HttpGet("http://10.0.2.2:82/AndroidRemoto/IngresoData.php"+parametros);
try{
response=httpClient.execute(httpget,localContext);
}catch(Exception ex){
Toast.makeText(getApplicationContext(), "error: "+ex,
}
return response.toString();
}
}
Realizar mantenimiento de Datos (Insert - Delete -Update).

ELIMINAR.JAVA
public class eliminarCod extends ActionBarActivity {
EditText txtCod;
Button btnEliminarCod;
@Override
setContentView(R.layout.activity_eliminar);
txtCod=(EditText) findViewById(R.id.txtEliminarCod);
btnEliminarCod=(Button) findViewById(R.id.btnEliminarCod);
btnEliminarCod.setOnClickListener(new OnClickListener() {
@Override
@Override
public void run() {

try{
final String res;
res=enviarGet(txtCod.getText().toString());
public void run() {
Toast.makeText(eliminarCod.this, res,
}
});
}
};
nt.start();
}
});
}
public String enviarGet(String c){
String parametros="?cod="+c;
HttpGet httpget = new
HttpGet("http://10.0.2.2:82/AndroidRemoto/EliminarData.php"+parametros);
//HttpGet httpget=new
HttpGet("http://127.0.0.1:82/AndroidRemoto/EliminarData.php"+parametros);
try{
}
}
}
LISTADO.JAVA
public class Listado extends ActionBarActivity {
@Override
setContentView(R.layout.activity_listado);
Thread tr=new Thread(){

@Override
public void run() {
final String resultado=leer();

@Override
public void run() {
cargaListado(obtDatosJSON(resultado));
}
}); } };
tr.start();
}
public ArrayList<String> obtDatosJSON(String response){

ArrayList<String> listado=new ArrayList<String>();
try{
JSONArray json=new JSONArray(response);
String texto="";
for(int i=0; i<json.length();i++){
texto=json.getJSONObject(i).getString("codUSU")+"-"+
json.getJSONObject(i).getString("nomUsu")+"-"+
json.getJSONObject(i).getString("edadUsu")+" - "+
json.getJSONObject(i).getString("sexo");
listado.add(texto);
}
return listado;
}
public String leer(){

HttpClient cliente=new DefaultHttpClient();
HttpContext contexto=new BasicHttpContext();
HttpGet httpget=new HttpGet("http://10.0.2.2:82/AndroidRemoto/GetData.php");
String resultado=null;
try{
HttpResponse response=cliente.execute(httpget,contexto);
HttpEntity entity=response.getEntity();
resultado=EntityUtils.toString(entity,"UTF-8");
return resultado;
}
public void cargaListado(ArrayList<String> datos){

ArrayAdapter<String> adaptador=new
ArrayAdapter<String>(this,android.R.layout.simple_list_item_1,datos);
ListView listado=(ListView) findViewById(R.id.listView1);
listado.setAdapter(adaptador);
} }

Crear el archivo ConsultaData.php
<?php
$nom=$_REQUEST['nom'];
$res=$cnx->query("select * from usuarios where nomUsu like '%$nom%'");
$datos=array();
$datos[]=$row;
}
?>
Crear el layout activity_Consultar
Crear la clase consultar.java
public class Consulta extends ActionBarActivity {
Button btnConsultar;
EditText txtC;
String c="";
@Override
setContentView(R.layout.activity_consultar);
txtC=(EditText) findViewById(R.id.txtCon);
btnConsultar=(Button) findViewById(R.id.btnConsultar);
btnConsultar.setOnClickListener(new OnClickListener() {
@Override
c=txtC.getText().toString();
@Override
public void run() {
final String resultado=leer(c);
@Override
public void run() {

cargaListado(obtDatosJSON(resultado));
}
});
}
};
tr.start();
}
});
public ArrayList<String> obtDatosJSON(String response){

ArrayList<String> listado=new ArrayList<String>();
try{
String texto="";
texto=json.getJSONObject(i).getString("codUSU")+"-"+
json.getJSONObject(i).getString("nomUsu")+"-"+
json.getJSONObject(i).getString("edadUsu")+" - "+
json.getJSONObject(i).getString("sexo");
listado.add(texto);
}
return listado;
}
public String leer(String nom){
HttpGet httpget=new
HttpGet("http://10.0.2.2:82/AndroidRemoto/ConsultaData.php?&nom="+nom);
try{
return resultado;
}
public void cargaListado(ArrayList<String> datos){
ArrayAdapter<String> adaptador=new
ArrayAdapter<String>(this,android.R.layout.simple_list_item_1,datos);
ListView listado=(ListView) findViewById(R.id.lstConsulta);

listado.setAdapter(adaptador);
}
}
Programar el botón consultar de la actividad principal.

btnConsultar=(Button) findViewById(R.id.btnConsul);
btnConsultar.setOnClickListener(new OnClickListener() {
@Override
Intent i=new
Intent(getApplicationContext(),Consulta.class);
startActivity(i);
}
});
Edicion de Datos
Creamos las paginas ConsultaData2.php y EditarData.php

CONSULTADATA2.PHP (Permite Buscar los datos por codigo)
<?php
$res=$cnx->query("select * from usuarios where codUsu like $cod");
$datos=array();
$datos[]=$row;
}
?>
EDITARDATA.PHP
<?php
$nom=$_REQUEST['nom'];
$edad=$_REQUEST['edad'];
$sexo=$_REQUEST['sexo'];
$res=$cnx->query("update usuarios set nomUsu='$nom',edadUsu=$edad,sexo='$sexo'
where codUsu=$cod");
?>
EDITAR.JAVA
public class Editar extends ActionBarActivity {

EditText txtCod,txtNom,txtEdad,txtSexo;
Button btnBuscar,btnEditar;
int c;
@Override
setContentView(R.layout.activity_editaruno);
txtCod=(EditText) findViewById(R.id.txtCodEditar1);
txtNom=(EditText) findViewById(R.id.txtNomEditar1);
txtEdad=(EditText) findViewById(R.id.txtEdadEditar1);
txtSexo=(EditText) findViewById(R.id.txtSexoEditar1);

btnBuscar=(Button) findViewById(R.id.btnConsultarEditar);
btnEditar=(Button) findViewById(R.id.btnEditarFinal1);
//BOTON BUSCAR
btnBuscar.setOnClickListener(new OnClickListener() {
@Override
c=Integer.parseInt(txtCod.getText().toString());
@Override
public void run() {
final String resultado=leer(c);
@Override
public void run() {
LlenarDatos(resultado);
}
});
}
};
tr.start();
}
});
//BOTON EDITAR
btnEditar.setOnClickListener(new OnClickListener() {
@Override
@Override
public void run() {
try{
final String res;
res=enviarGet(txtCod.getText().toString(),txtNom.getText().toString(),txtEdad.ge
tText().toString(),txtSexo.getText().toString());
public void run() {
Toast.makeText(Editar.this, res,
}
});
}
};
nt.start();

}
});
}
//METODO PARA LLENAR LOS TEXTBOX
public void LlenarDatos(String response){
try{
txtNom.setText(json.getJSONObject(i).getString("nomUsu"));
txtEdad.setText(json.getJSONObject(i).getString("edadUsu"));
txtSexo.setText(json.getJSONObject(i).getString("sexo"));
}
}
//METODO PARA LEER LOS DATOS
public String leer(int cod){
HttpGet httpget=new
HttpGet("http://10.0.2.2:82/AndroidRemoto/ConsultaData2.php?&cod="+cod);
try{
return resultado;
}
//METODO PARA EDITAR
public String enviarGet(String c, String n, String e, String s){
String parametros="?&cod="+c+"&nom="+n+"&edad="+e+"&sexo="+s;
HttpGet httpget=new
HttpGet("http://10.0.2.2:82/AndroidRemoto/EditarData.php"+parametros);
try{


}
}
}
PROGRAMAR EL BOTÓN EDITAR DEL MAIN_ACTIVITY PARA QUE

LLAME A LA VENTANA.
btnConsultarEditar=(Button) findViewById(R.id.btnConsultarEditar);
btnConsultarEditar.setOnClickListener(new OnClickListener() {
@Override
Intent i=new Intent(getApplicationContext(),Editar.class);
startActivity(i);
}
});
LOGUEO

ANDROID1.PHP
<?php
$usu=$_REQUEST['usu'];
$pas=$_REQUEST['pas'];
$cnx=new PDO("mysql:host=localhost;dbname=android","root","");
$res=$cnx->query("select * from usuarios where codUsu='$usu' and pasUsu='$pas'");
$datos=array();
$datos[]=$row;
}
?>
MAINACTIVITY.PHP
Button btnIngresar;
EditText txtUsu,txtPas;
String usu="",pas="";
@Override
txtUsu=(EditText) findViewById(R.id.txtUsu);
txtPas=(EditText) findViewById(R.id.txtPas);
btnIngresar=(Button) findViewById(R.id.btnIngresar);
btnIngresar.setOnClickListener(new OnClickListener() {
@Override
usu=txtUsu.getText().toString();
pas=txtPas.getText().toString();
@Override
public void run() {
final String resultado=leer(usu,pas);
@Override
public void run() {

int r=obtDatosJSON(resultado);
if(r>0){
Intent i=new Intent(getApplicationContext(),MainPrincipal.class);
startActivity(i);
}else{
Toast.makeText(getApplicationContext(), "Incorrecto",
}
}
});
}
};
tr.start();
}
});
public int obtDatosJSON(String response){

int res=0;
try{
if(json.length()>0){
res=1;
}
return res;
}
public String leer(String usu, String pas){

HttpGet httpget=new
HttpGet("http://10.0.2.2:82/android/android1.php?&usu="+usu+"&pas="+pas);
try{
return resultado;
}

1. ¿Cuál es la diferencia entre GET y POST?

2. ¿Qué signifca JASON?
3. ¿Qué es un JSONObject?
4. ¿De qué manera los ayudan los objetos JSON en una aplicación con
servicios web?

Desarrollo de Aplicaciones Móviles

Încărcat de

Informații document

Titlu original

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Desarrollo de Aplicaciones Móviles

Încărcat de

Drepturi de autor:

Formate disponibile

SERVICIO NACIONAL DE ADIESTRAMIENTO EN TRABAJO INDUSTRIAL

ESCUELA DE TECNOLOGÍAS DE LA INFORMACIÓN 4

En la actualidad los móviles con sistemas operativos Android venden y se

El éxito de este gran sistema operativo se puede basar en la gran cantidad de

El 25 de junio de 2014 la empresa Google mostró un producto más

ESCUELA DE TECNOLOGÍAS DE LA INFORMACIÓN 5

El creador del S.O. Android fue el ingeniero de telecomunicaciones Andy Rubin

Hasta el momento ya teníamos a Andy Rubin trabajando para Apple y

Después de 2 fracasos Andy rubin decisión fundar su propia empresa llamada

Una de las primeras cosas que se desarrolla en Danger es primer teléfono

En Agosto de 2005, Google adquirió la empresa, pero al momento de adquirirlo

ESCUELA DE TECNOLOGÍAS DE LA INFORMACIÓN 6

Durante 16 años android fue madurando en la cabeza de Andy ya que toda su

Pero después de que Andy ingresara a la empresa y trabajara unos años

LA OPEN HANDSET ALLIANCE.

La Open Handset Alliance se le llama a toda la agrupación de mas de 100

Cada uno de los integrantes de la Open Handset Alliance está muy

Miembros de la Open Handset Alliance.

ESCUELA DE TECNOLOGÍAS DE LA INFORMACIÓN 7

Un S.O Móvil es un sistema que es capaza de controlar un dispositivo móvil

Entre los sistemas operativos más conocidos se tienen:

Esta disponibilidad fácil del sistema operativo a

ESCUELA DE TECNOLOGÍAS DE LA INFORMACIÓN 8

de esto cada uno de los fabricantes o personas que utilizan el sistema

iOS Su principal característica del sistema

Lo explicado tiene sus ventajas y desventajas ya que para un creador puede

ESCUELA DE TECNOLOGÍAS DE LA INFORMACIÓN 9

Todas sus aplicaciones requieren de un paquete comprimirdo el cual se

ESCUELA DE TECNOLOGÍAS DE LA INFORMACIÓN 10

consumidores. Los esfuerzos echos por la empresa BlackBerry para poder

Con el pasar de los años el sistema Operativo Android ha tenido muchas

Desde un primer momento Google ha puesto a cada uno de sus versiones

Apple Pie (Tarta de Manzana).

Banana Bread (Pan de Banana).

ESCUELA DE TECNOLOGÍAS DE LA INFORMACIÓN 11

- Esta versión tampoco se porto comercialmente, fue versión beta.

Android 1.5 o Cupcake (magdalena).

En esta versión no se agregaron muchos cambios a la plataforma

Android 1.6 o Donut.

En esta versión también podemos notar un cambio en la interfaz

Android 2.0 o Eclair (rollo de crema).

Android 2.2 o Froyo (yogourt helado).

ESCUELA DE TECNOLOGÍAS DE LA INFORMACIÓN 12

Android 2.3 o Gingerbread (galletas de jengibre).

Tambien en esta versión tenemos como innovación el teclado, y

En esta versione también notamos un nuevo android market con un mejor

Android 3.0 o HoneyComb (panal de abeja).

Android 4.0 o Ice Cream Sandwich (sandwich de helado).

Además se agregan nuevas funciones en la barra de notificaciones, así como

Android 4.1 o Jelly Bean (caramelitos).

ESCUELA DE TECNOLOGÍAS DE LA INFORMACIÓN 13

agregan un nuevo sistema de notificaciones que se encuentran en la misma

Se mejora la conectividad con soporte de NFC para emular

Se facilita el acceso de las aplicaciones a la nube con un nuevo marco de

Lollipop Android 5.0

Con respecto al diseño de la interfaz se han incluido botones en la parte inferior

ESCUELA DE TECNOLOGÍAS DE LA INFORMACIÓN 14

Además la nueva versión cuenta con un modo de bloqueo que impide al

ESCUELA DE TECNOLOGÍAS DE LA INFORMACIÓN 15

sensores que vienen incluidos en el dispositivo, localización que nos sirven

La ventaja más resaltante de utilizar el entorno de desarrollo es que aprovecha

Los servicios más importantes que incluye son:

- Views: Son las vistas que no sirven para el diseño.