Guia de Aprendizaje de Programacion M3S2

MODULO III DESARROLLA APLICACIONES WEB Y MOVILES
Mapa curricular:
Submdulo 1 - Desarrolla aplicaciones web
Submdulo 2 - Desarrolla aplicaciones mviles
ndice
Introduccin al submdulo
Objetivo General
Mapa Curricular
Mapa de Contenidos
Cronograma
Ponderaciones
Desarrollo de las Esferas de Competencia
Cierre del Submdulo
Bibliografa
Glosario
Anexos
Plan de Evaluacin
Gua del Portafolio
Instrumentos de Evaluacin
Proyecto Integrador
Elaboraron:
Lic. Esteban Angeles Molina
Ing. Susana Hernndez Ramrez
Lic. Renn Abreu Guerrero
Ing. Lorena Ramrez Campoy
Introduccin al submdulo
Es indudable el vertiginoso avance de las posibilidades que tiene los dispositivos
mviles actuales en la comunicacin por diversas vas, el acceso a servicios de
forma remota y mvil y el manejo de aplicaciones hasta hace poco tiempo slo
reservadas a plataformas fijas.
El curso tiene, como primer objetivo, dar una panormica general de la tecnologa
que soporta estos avances y la que hay para el desarrollo de aplicaciones y el
soporte de servicios mediante dispositivos mviles, profundizndose en las
plataformas de programacin, lenguajes y entornos de ejecucin y de desarrollo
ms usados en la actualidad.
Finalmente se propondrn desarrollos sencillos de programacin de aplicaciones

adaptados a los conocimientos de cada alumno para poner en prctica lo visto de
forma terica y para reafirmar al alumno en las posibilidades de desarrollo que
tienes estas plataformas.
Cuando hablamos de desarrollar software para dispositivos mviles, lo primero

que se nos viene a la mente es el desarrollo para telfonos celulares, pero, en
muchas ocasiones, no tenemos claro qu debemos hacer; Un sitio Web? Una
aplicacin para el celular?
Lo cierto es que, un dispositivo mvil no es solo un celular, y que adems, el
software a desarrollar, puede ser, tanto un sitio Web, como una aplicacin nativa
para el dispositivo.
Los celulares no son los nicos dispositivos mviles para los cuales podemos
desarrollar.
Podramos programar para otros dispositivos como Palm, Pocket PC, Ipod Touch.
En fin, dispositivos de mano pequeos con ciertamente, una gran potencia.
Objetivo general.
El alumno ser capaz de desarrollar aplicaciones mviles sobre plataformas

abiertas y cerradas utilizando diferentes SDKs ejecutndolas tanto en tablets como
en smartphones.
Mapa curricular
Mapa de competencias profesionales de la carrera de Tcnico en
programacin
Mapa de Contenidos
Modulo 3 Desarrolla aplicaciones web y mviles
Submdulo 2 Desarrolla aplicaciones mviles
Competencia 1
Desarrolla aplicaciones para dispositivos mviles sobre plataformas abiertas
Atributos de la competencia
1.
2.
3.
4.
5.
Conceptos bsicos
Conocer una plataforma abierta
Conocer los dispositivos mviles de plataforma abierta
Conocer la programacin del mvil
Desarrollo de aplicaciones
Saberes:
1)
2)
3)
4)
5)
6)
Conceptos bsicos de programacin orientado a objetos POO Java

Entorno de Eclipse
Conocimientos bsicos de XML
SDK
Entorno de Android (AVD)
Desarrollo de aplicaciones
Actitudes:
1. Limpieza
2. Responsabilidad
3. Orden
Competencia 2
Desarrolla aplicaciones para dispositivos mviles sobre plataformas cerradas
Atributos de la competencia:
1. Conocer una plataforma cerrada
2. Conocer los dispositivos mviles de plataforma cerrada

3. Conocer las caractersticas, ventajas y desventajas de las plataformas
cerradas.
Saberes:
1.
Actitudes:
1. Limpieza
2. Responsabilidad
3. Orden
Cronograma (ANEXO ARCHIVO M3S1 Excel)
Ponderaciones
En el Submdulo 2
Evidencia de Producto
Evidencia de Desempeo
Evidencia de Actitud
Evidencia de Conocimiento
Desarrollo de las Esferas de Competencia

Competencia 1 Desarrolla aplicaciones para dispositivos mviles sobre
plataformas abiertas.
Saberes
1. Conceptos bsicos
2. Conocer tipos de plataformas
3. Conocer los dispositivos mviles de plataforma abierta
4. Conocer la programacin del mvil
5. Desarrollo de aplicaciones
Ejemplos:
1. Antecedentes
2. Te presento a Android
3. Instalando Android
4. Mi primer programa
5. Conociendo ms de Java en Eclipse
Ejercicios:
1. Tabla comparativa de sistemas operativos para plataformas libres

2. Usando Edith Text
3. Edith Text
4. Radio Group
5. Radio Button
6. Check box
7. Spinner
8. Image Button
9. Un segundo Activity
10. Paso de parmetros.
11. Almacenamiento de datos en un archivo de texto en memoria interna , y en
tarjetas SD
12. Layouts
Prctica Integradora:
1. Programando mi pone
Introduccin a la Competencia 1
Las plataformas abiertas son aquellas que permiten adaptarlas a las necesidades
creando ventajas competitivas para la empresa.
Las Tecnologas de la Informacin juegan hoy en da un factor determinante en la
competitividad de las empresas. El seleccionar y mantener una cartera tecnolgica
competitiva es uno de los grandes retos, en especial para las PyMEs.
La evolucin acelerada de la tecnologa presenta un enorme reto, desde el punto
de vista de gestin del conocimiento, lograr soluciones competitivas con fuertes
diferenciales y alternativas correctas. Adoptar un producto abierto, como una
plataforma para desarrollar diferenciales de negocio positivos, es una alternativa
altamente competitiva que permite reducir sustancialmente los costos asociados a
la innovacin.
Cmo se ofrecen las plataformas libres?
Las plataformas abiertas son aquellas que permiten adaptarse a las necesidades
creando ventajas para la empresa, negocio, o simplemente mejorar la manera en
que se realizan diferentes actividades importantes para las organizaciones. Este
tipo de plataformas no tienen un costo de licenciamiento, pero la mayora tienen
un costo implcito asociado a la adaptacin, segn los requerimientos de cada
empresa. La mayora de las veces la adaptacin se tiene que hacer por un
profesional que conozca la tecnologa y plataforma.
Hoy en da se puede decir que hay muy pocas soluciones que se puedan
considerar netamente comerciales o totalmente abiertas. En la mayora de los
casos, se pueden realizar acuerdos o convenios con los diferentes proveedores
para que den acceso al cdigo fuente para poder modificarlo.
El principal modelo de negocio con el que se ofrecen las plataformas libres se
denomina gift economy o economa del regalo. El regalo en las plataformas
abiertas es una licencia, generalmente sin costo que permite usar y modificar las
soluciones segn las necesidades. Pero, qu ganan las empresas al regalar el
software?
Los principales ingresos estn en los servicios de soporte para adaptarse a necesidades
especficas, en lugar de cuotas para el uso (licencias), los servicios que se ofrecen deben ser de
gran valor para la competitividad,
El mejor ejemplo de tecnologas abiertas hoy en da es Android que tiene la mayor
penetracin en el mercado de mviles. Android es un producto abierto (Linux) adaptado a
una necesidad especfica como lo es el mercado de los smartphones. Es capaz de ser
instalado en mltiples dispositivos mviles creados por diferentes marcas y al mismo
tiempo cuenta con una amplia variedad de aplicaciones que en su mayora son gratuitas.
Iniciamos.
Atributos de la Competencia
1. Conceptos bsicos
2. Conocer una plataforma abierta
3. Conocer los dispositivos mviles de plataforma abierta
4. Conocer la programacin del mvil
5. Desarrollo de aplicaciones
Resultado de Aprendizaje
Una vez que se logren adquirir las habilidades necesarias a travs del dominio de
la competencia y sus atributos, podr realizar aplicaciones mviles que podrs
traer en el bolsillo..
(No. 1)
Saberes
TITULO
1.
2.
Recordando la POO
Sentencias bsicas de Java
Instrucciones para el alumno: El alumno analizara los tres mtodos o

estrategias para el desarrollo de sistemas; los cuales le darn la pauta de elegir el
que le convenga para generar la solucin mas optima a sus problemas.
Actitudes:
1. Orden.
2. Puntualidad.
3. Responsabilidad.
Saberes a adquirir
Competencias Genricas:
. Se expresa y comunica.
Escucha, interpreta y emite mensajes pertinentes en distintos contextos

mediante la utilizacin de medios, cdigos y herramientas apropiados.
Manera didctica de lograrla:
A travs de una actitud de orden, tomando en cuenta la investigacin sustenta con
acervo bibliogrfico.
Instrucciones para el alumno|

1. Realiza un mapa conceptual de los principales conceptos de la
programacin orientada a objetos, como: clase, objeto, mtodo,
encapsulamiento, atributo, herencia, etc.
Saberes a adquirir
Recordar los conceptos bsicos que se manipularan de forma cotidiana durante el
desarrollo del submdulo, as como nuevos conceptos que se deban adquirir.
Mtodo didctico
Por medio de un mapa conceptual se definirn los conceptos bsicos utilizados en
la programacin orientada a objetos, escribiendo la fuente bibliogrfica utilizada.
Ejemplo
(No. 1)
TABLA DE SENTENCIAS BSICAS

DE JAVA
Titulo:
Instrucciones para el alumno: En la siguiente tabla, escribe en cada uno de los

cuadros la informacin que hace falta.
Sentencia
Uso
int i=1;
Declaracin
entero
de
variable
tipo
System.out.println("Mi primer
programa");
...
Actitudes:
1.
2.
3.
4.
5.
Limpieza.
Orden.
Respeto.
Puntualidad.
Responsabilidad.
Competencias Genricas: Escucha, interpreta y emite mensajes

A travs de una actitud de orden, tomando en cuenta la investigacin sustentada
con acervo bibliogrfico.
Ejemplo
(No. 2)
TABLA
COMPARATIVA
DE
SISTEMAS OPERATIVOS MOVILES EN
PLATAFORMAS ABIERTAS.
Titulo:
Instrucciones para el alumno: Realiza una tabla comparativa de los diferentes

sistemas operativos mviles, tomando en cuenta el nombre del sistema operativo,
principales caractersticas como su capacidad de procesamiento, ventajas,
desventajas, aplicaciones existentes, etc..
Actitudes:
1.
2.
3.
4.
5.
Limpieza.
Orden.
Respeto.
Puntualidad.
Responsabilidad.
Competencias Genricas: Escucha, interpreta y emite mensajes

(No. 2)
Saberes
TITULO
1.
Antecedentes de la programacin mvil
Instrucciones para el alumno: El alumno conocer los orgenes de la

programacin mvil, los cuales le darn la pauta de elegir el que le convenga
para generar la solucin ms ptima a sus problemas.
Actitudes:
Orden.
Puntualidad.
Responsabilidad.
Saberes a adquirir
A travs de una actitud de orden, tomando en cuenta la investigacin sustenta
ANTECEDENTES:
Aunque el sistema operativo Android tiene algunos aos de vida, la librera Java
de android consiste ya en ms de 150 paquetes (APIs), que contienen miles de
clases, mtodos, interfaces y constantes. Para mayor informacin se puede
verificar en la pgina web de Android Developers.
Android es un Linux basado en sistema operativo diseado principalmente para
la pantalla tctil de los dispositivos mviles como telfonos inteligentes y Tablet
PC . Desarrollado inicialmente por Android Inc., que Google respaldada
financieramente y ms tarde adquiri en 2005, Android se dio a conocer en 2007
con
la
fundacin
de
la Open
Handset
Alliance :
un
consorcio
de hardware , software y telecomunicaciones
empresas
dedicadas
a
la
promocin abierta normas para los dispositivos mviles. El primer telfono con
Android fue vendido en octubre de 2008.
Android es de cdigo abierto y Google libera el cdigo bajo la licencia
Apache . Este cdigo fuente abierto y licencia permisiva permite que el software
para ser modificado y distribuido libremente por los fabricantes de dispositivos,
operadores mviles y desarrolladores entusiastas. Adems, Android tiene una
gran comunidad de desarrolladores que escriben aplicaciones (" apps ") que
amplan la funcionalidad de los dispositivos, escrito principalmente en una versin
personalizada de la Java lenguaje de programacin. En octubre de 2012, haba
aproximadamente 700.000 aplicaciones disponibles para Android , y la estimacin
del nmero de aplicaciones descargadas de Google Play , tienda de aplicaciones
de Android primaria, fue de 25 millones de dlares.
Estos factores han permitido a Android para convertirse en la plataforma ms
utilizada telfono inteligente y el software de eleccin para las empresas de
tecnologa que requieren un bajo costo, sistema personalizable, operativo ligero
de alta tecnologa, dispositivos sin desarrollar uno desde cero. Como resultado, a
pesar de estar diseado principalmente para telfonos y tabletas, se ha visto
aplicaciones adicionales en televisores , consolas de videojuegos y otros aparatos
electrnicos. Naturaleza abierta de Android ha alentado una gran comunidad de
desarrolladores y entusiastas de utilizar el cdigo de fuente abierta como una base
para impulsadas por proyectos comunitarios, que aaden nuevas caractersticas
para usuarios avanzados o llevar Android a los dispositivos que fueron lanzados
oficialmente funcionando como sistema operativo.
Clasificacin de los dispositivos mviles
En la dcada de los 90, tras la aparicin de estos primeros dispositivos, se

establecieron clasificaciones ms o menos rigurosas era posible debido a que
cada aparato estaba claramente definido para una funcin determinada o para un
pblico concreto. Por ejemplo, un smartphone representa una evolucin de un
telfono mvil tradicional, su cometido es ofrecer comunicacin telefnica; sin
embargo, cuenta con otros servicios adicionales como la conexin a Internet y
aplicaciones, servicios propios de un ordenador, cmara de fotos y de vdeo o la
posibilidad de reproducir pelculas o videojuegos.
La clasificacin que a aqu se propone utilizar como principal criterio la
funcionalidad o servicio principal para la que ha sido diseado bien el propio
dispositivo mvil, o bien aquel dispositivo del que directamente procede y del que
supone una evolucin mejorada.
Los dispositivos mviles pueden ser clasificados en los siguientes grupos:
Dispositivo de comunicacin: Un dispositivo de comunicacin es aquel

dispositivo mvil cuyo cometido principal es ofrecer una infraestructura de
comunicacin, principalmente telefnica. Estos dispositivos ofrecen adems
servicios como el envo de mensajes SMS y MMS, o acceso WAP.
Adems se incluira el tradicional telfono mvil, precursor indiscutible dentro de

los
dispositivos
mviles,
la
BlackBerry
el
smartphone,
que
ampla
considerablemente las prestaciones del primero mediante pantalla tctil, conexin

a Internet o la ejecucin de aplicaciones (por ejemplo, iPhone o HTC G1).
Dispositivo de computacin: Los dispositivos de computacin son aquellos

dispositivos mviles que ofrecen mayores capacidades de procesamiento
de datos y cuentan con una pantalla y
teclado ms cercanos a un
ordenador de sobremesa. Dentro de los dispositivos mviles son sin duda

los que mayores prestaciones hardware ofrecen un mayor tamao, peso y
precio.
Smartphone: (cuya traduccin en espaol sera telfono inteligente) es una

evolucin del telfono mvil tradicional que cuenta con ciertas caractersticas y
prestaciones que lo acercan ms a un ordenador personal que a un telfono
tradicional. Las caractersticas, se puede encontrar una mejora en la capacidad de
proceso y almacenamiento de datos, conexin a Internet mediante Wi-Fi, pantalla
tctil, acelermetro, posicionador geogrfico, teclado QWERTY y diversas
aplicaciones de usuario como navegador web, cliente de correo, aplicaciones
ofimticas, reproductores de vdeo y audio, etc. incluyendo la posibilidad de
descargar e instalar otras nuevas.
Los smartphone las limitaciones se reflejan en pantallas ms pequeas, menor
capacidad del procesador, restricciones de memoria RAM y memoria persistente,
y necesidad de adaptar el consumo de energa a la capacidad de una pequea
batera.
Funciones del emulador: El SDK de Android incluye un completo emulador que
permite
probar
desarrollando.
y depurar eficientemente
Este
emulador
incluye
las
aplicaciones
diferentes
skins
que
para
se van
representar
grficamente un dispositivo mvil real, con pantalla, teclado y botones de funcin,

as como aplicaciones de usuario preinstaladas que incluyen navegador web o
visor de mapa, y una consola que permite interactuar con l a travs de Telnet.
Saberes
N3
Instalacin de Android
En este apartado el profesor explicar la manera de instalar el emulador del

sistema operativo, utilizando tecnologas de informacin para su apoyo.
Descarga de herramientas necesarios para programar para Android.
1 - Primero debemos instalar el compilador de Java y la mquina virtual. Estas

herramientas las podemos descargar de:
Java SE Development Kit (JDK).
2 - El segundo paso es la descarga del editor Eclipse, lo hacemos del sitio:
Eclipse IDE for Java Developers.
3 - El tercer paso es descargar el SDK Android, lo podemos descargar de:
SDK de Android
El archivo que descargaremos es el zip: android-sdk_rxx-windows.zip (donde xx
es el nmero de la ltima versin)
Descomprimimos el archivo y lo ubicamos en la raiz de la unidad c\:, luego de
descomprimir tenemos una carpeta llamada: c:\android-sdk-windows
4 - El cuarto paso es ejecutar el programa: c:\android-sdk-windows\SDK
Manager.exe
que se encuentra en la carpeta que acabamos de descomprimir el SDK de
Android.
Aparece esta ventana (presionamos cancelar con el objetivo de seleccionar una
AVD (Android Virtual Device) y no tener que esperar una eternidad descargando
todas las versiones de AVD):
Instalaremos en primera instancia la versin del SDK 2.3.3 (la lnea 2 est
orientada al desarrollo de aplicaciones para celulares y la lnea 3 est orientada a
tablet). Seleccionamos Available packages y luego del lado derecho solo dejamos
tildado la versin del SDK 2.3.3 (ms adelante podemos instalar otras versiones
de Android) Por ltimo procedemos a presionar el botn "Install Selected":
Aparece
un
dilogo
donde
nos
informa
el
progreso
de
instalacin:
Ahora ya podemos cerrar la aplicacin del SDK Manager.exe

5 - Instalacin del plugin de Eclipse para trabajar con Android.
Para instalar el plugin ingresamos al entorno Eclipse. Luego desde el men de
opciones: Help-> Install New Software, aparece el siguiente dilogo, presionamos
el botn add y disponemos la url donde se encuentra el plugin:
En Location disponemos la url: https://dl-ssl.google.com/android/eclipse/

Tildamos "Developer Tools", presionamos seguidamente el botn "Next" dos
veces hasta que aparece la ventana donde tenemos que aceptar los "Trminos y
Condiciones"
y
presionamos
el
botn
"Finish"
Al finalizar la instalacin del plugin se reinicia el Eclipse para que se instale
completamente.
6 - El siguiente paso que debemos efectuar para poder empezar a desarrollar
aplicaciones
para
Android
es
configurar
el
SDK:
Para esto nos dirigimos a la opcin Windows -> Preferences donde aparece el
siguiente
dilogo:
Seleccionamos la carpeta donde descomprimimos SDK de Android y presionamos

el botn "Apply"
7 - Por ltimo debemos crear el AVD (Android Virtual Device) para ello nos
dirigimos a la opcin Window -> Android SDK and AVD Manager.
En este dilogo debemos crear el emulador de Android (presionamos el botn
New...):
En este dilogo asignamos un nombre a nuestro AVD, lo enlazamos con la versin
de
SDK
respectivo,
fijamos
un
tamao
al
SD
Ya tenemos todo configurado para el desarrollo de aplicaciones Android.
Saberes
N3
Mi primer programa
Card:
SABERES A ADQUIRIR
Conocer la estructura y funcionamiento de Eclipse.
Ya tenemos todo lo necesario instalado para implementar el primer proyecto.

Desde el men de opciones: File -> New -> Android Project
En este dilogo especificamos el nombre del proyecto y el nombre del paquete

java donde se almacenarn los archivos java que creemos.
El plugin de Android nos genera todos los directorios y archivos bsicos para
iniciar nuestro proyecto:
No haremos en este momento un anlisis del significado y objetivo de cada

uno de estos directorios y archivos generados, sino a medida que avancemos
con este curso iremos viendo en forma puntual y profunda.
La interfaz visual de nuestro programa para Android se almacena en un archivo
XML en la carpeta res, subcarpeta layout y el archivo se llama main.xml. En
esta carpeta tenemos creada nuestra primer pantalla.
Al seleccionar este archivo el plugin de Android nos permite visualizar el
contenido en "vista de diseo (Graphical Layout)":
Si seleccionamos la otra pestaa podemos visualizar el archivo main.xml en

formato de texto:
El plugin Android ya insert un control de tipo LinealLayout que especifica que

todos los controles visuales que se inserten se dispondrn uno debajo del otro
ya que la propiedad orientation est inicializada con el valor vertical
(orientation="vertical")
Ya veremos que podemos modificar todo este archivo para que se adapte a la
aplicacin que queremos desarrollar.
Luego contenido en el control LinealLayout hay otro control de tipo TextView
que es bsicamente una etiqueta o label que mostrar en pantalla el valor
almacenado en la propiedad text.
Podemos modificar directamente el archivo xml o en "vista de diseo" modificar
los valores de las propiedades. Elegimos nuevamente la pestaa "Graphical
Layout" y seleccionamos el TextView con el mouse y presionamos el botn
derecho del mouse, buscamos la propiedad text y la cambiamos por la
etiqueta: "Mi primer programa para Android":
Con esto ya podemos probar nuestra primer aplicacin para un dispositivo

Android. Presionamos Run desde el men o el cono respectivo.
Seleccionamos que se ejecute como aplicacin "Android Application". Ahora se
abrir el AVD(Android Virtual Device) esto tarda bastante tiempo, es muy
importante recordar que luego de ver ejecutndose el programa NO debemos
cerrar el AVD para que la prxima ejecucin se inicie ms rpido (podemos
minimizar el AVD)
Ahora podemos ver nuestra primer aplicacin corriendo en el emulador de
Android:
Como hemos visto el plugin de Eclipse nos genera en forma automtica todas
las carpetas y archivos bsicos que necesitamos en un principio. En el
siguiente concepto podremos empezar a programar verdaderamente. El nico
objetivo de este ejercicio es recordar los pasos para crear un proyecto.
Saberes
N4
Conociendo ms de Java en Eclipse.

SABERES A ADQUIRIR
Controles:
Edith Text
Radio Group
Radio Button
Check box
Spinner
Image Button
Un segundo Activity
Paso de parmetros.
Almacenamiento de datos en un archivo de texto en memoria
interna , y en tarjetas SD
Layouts
Captura del clic de un botn

Problema:
Realizar la carga de dos nmeros en controles de tipo EditText. Mostrar un

mensaje que solicite la carga de los valores. Disponer un Button para sumar
los dos valores ingresados. Mostrar el resultado en un tercer TextView.
La
interfaz
visual
debe
quedar
algo
semejante
a
esto:
Veamos paso a paso como creamos la interfaz visual de nuestro programa.

Primero borramos el TextView que aparece por defecto cuando se crea un
proyecto con el plugin de Android. Ahora desde la ventana "Palette"
seleccionamos de la pestaa "Form Widgets" el control "TextView" y lo
arrastramos a la ventana de diseo de nuestra interfaz:
Ahora lo seleccionamos y presionamos el botn derecho del mouse sobre la

componente y especificamos la propiedad text (como habamos visto
anteriormente) disponemos el texto "Ingrese el primer valor:":
Tambin vamos a especificar la propiedad "Id", la misma parece primera en el

men
contextual:
Le asignaremos como nombre a este objeto: tv1 (recordemos que se trata de

un objeto de la clase TextView)
Ahora de la paleta de componentes seleccionamos la pestaa "Text Fields" y
arrastramos
el
primero
(el
que
tiene
la
etiqueta
abc)
Presionando el botn derecho sobre el control EditText configuramos la

propiedad Id... con el nombre et1 (este nombre haremos referencia
posteriormente desde Java)
Efectuamos los mismos pasos para crear el segundo TextView y EditText
(inicializamos las propiedades respectivas) Definimos los id con los nombres
tv2 y et2, el resultado visual debe ser algo semejante a esto:
De la pestaa "Form Widgets" arrastramos un control de tipo "Button":
Inicializamos la propiedad text con el texto "Sumar" y la propiedad id la

dejamos con el valor ya creado llamado "button1".
Para terminar con nuestra interfaz visual arrastramos un tercer objeto de tipo
TextView y definimos la propiedad id con el valor "tv3" y la propiedad text con
el texto "resultado", recordemos que la interfaz final debe ser semejante a esta:
Si en este momento ejecutamos la aplicacin aparece la interfaz visual

correctamente pero cuando presionemos el botn no mostrar la suma.
Hasta ahora hemos trabajado solo con el archivo xml (main.xml) donde se
definen los controles visuales de la ventana que estamos creando.
Abrimos seguidamente el archivo Proyecto002Activity.java que lo podemos
ubicar en la carpeta src:
La clase Proyecto002Activity hereda de la clase Activity. La clase Activity

representa una ventana de Android y tiene todos los mtodos necesarios para
crear y mostrar los objetos que hemos dispuesto en el archivo xml.
El cdigo fuente de la clase Proyecto002Activity.java es:
package androidya.proyecto002;
import android.app.Activity;
import android.os.Bundle;
public class Proyecto002Activity extends Activity
{
/** Called when the activity is first
created. */
@Override
public void onCreate(Bundle
savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
}
}
Como mnimo se debe sobrescribir el mtodo onCreate heredado de la clase

Activity donde procedemos a llamar la mtodo setContentView pasando como
referencia una valor almacenado en una constante llamada main contenida en
una clase llamada layout que a su vez la contiene una clase llamada R
(veremos ms adelante que el plugin de Eclipse para Android se encarga de
crear la clase R en forma automtica y sirve como puente entre el archivo xml y
nuestra clase Proyecto002Activity)
Captura de eventos.
Ahora viene la parte donde definimos variables en java donde almacenamos

las referencias a los objetos definidos en el archivo XML.
Definimos tres variables, dos de tipo EditText y finalmente una de tipo TextView
(estas dos clases de declaran en el paquete android.widget, es necesario
importar dichas clases para poder definir las variables de dichas clases):
import
import
import
import
android.app.Activity;
android.os.Bundle;
android.widget.EditText;
android.widget.TextView;

{
private EditText et1,et2;
private TextView tv3;
created. */
@Override
}
}
Los nombres que le d a los objetos en este caso coinciden con la propiedad id
(no es obligatorio):
No definimos TextView para los dos mensajes "Ingrese el primer valor" e

"Ingrese el segundo valor" ya que no necesitaremos interactuar con ellos.
Tambin veremos que el objeto de la clase Button no es necesario definir un
atributo sino que desde el archivo XML inicializaremos la propiedad OnClick.
En el mtodo onCreate debemos enlazar estas variables con los objetos
definidos en el archivo XML, esto se hace llamando al mtodo findViewById:
public void onCreate(Bundle savedInstanceState) {
et1=(EditText)findViewById(R.id.et1);
tv3=(TextView)findViewById(R.id.tv3);
}
Al mtodo findViewById debemos pasar la constante creada en la clase R

(recordemos que se crea automticamente esta clase) el nombre de la
constante si debe ser igual con el nombre de la propiedad del objeto creado en
el archivo XML. Como la clase findViewById retorna una clase de tipo View
luego debemos utilizar el operador cast (es decir le antecedemos entre
parntesis el nombre de la clase)
Ya tenemos almacenados en las variables las referencias a los tres objetos
que se crean al llamar al mtodo:setContentView(R.layout.main); .
Ahora planteamos el mtodo que se ejecutar cuando se presione el botn (el
mtodo debe recibir como parmetro un objeto de la clase View) En nuestro
ejemplo lo llam sumar:
import
import
import
import
import
android.os.Bundle;
android.view.View;

{
created. */
@Override

}
//Este mtodo se ejecutar cuando se presione
el botn
public void sumar(View view) {
}
}
Ahora debemos ir al archivo XML e inicializar la propiedad OnClick del objeto
button1 con el nombre del mtodo que acabamos de crear (este paso es
fundamental para que el objeto de la clase Button pueda llamar al mtodo
sumar que acabamos de crear):
Finalmente implementaremos la lgica para sumar los dos valores ingresados

en los controles EditText:
String valor1=et1.getText().toString();
int nro1=Integer.parseInt(valor1);
int suma=nro1+nro2;
String resu=String.valueOf(suma);
tv3.setText(resu);
}
Extraemos el texto de los dos controles de tipo EditText y los almacenamos en

dos variables locales de tipo String. Convertimos los String a tipo entero, los
sumamos y el resultado lo enviamos al TextView donde se muestra la suma
(previo a convertir la suma a String)
La clase completa queda entonces como:
import
import
import
import
import
android.os.Bundle;
android.view.View;

{
created. */
@Override
}
el botn
int suma=nro1+nro2;
tv3.setText(resu);
}
}
Si ejecutamos nuestro programa podemos ver ahora que luego de cargar dos
valores al presionar el botn aparece en el tercer TextView el resultado de la
suma de los dos EditText:
Controles RadioGroup y RadioButton

El objetivo de este concepto es practicar la implementacin de un programa
que requiera controles de tipo RadioButton para seleccionar una actividad.
Aprenderemos como agrupar un conjunto de RadioButton y verificar cual est
seleccionado.
Problema:

mensaje que solicite la carga de los valores. Disponer dos controles de tipo
RadioButton para seleccionar si queremos sumar o restar dichos valores.
Finalmente mediante un control de tipo Button efectuamos la operacin

respectiva. Mostramos el resultado en un TextView.
El problema es similar al anterior. Para disponer los controles de tipo
RadioButton debemos en realidad primero insertar un control de tipo
RadioGroup (este control se encuentra en la paleta de componentes en la
pestaa FormWidgets):
Cuando arrastramos el control RadioGroup al formulario se generan

automticamente 3 objetos de la clase RadioButton contenidos dentro del
RadioGroup, podemos fcilmente identificar que los controles RadioButton
pertenecen a dicho RadioGroup viendo la ventana de "Outline" del Eclipse
(donde nos muestra todos los controles insertados hasta el momento):
Nuestro problema solo requiere dos controles de tipo RadioButton. Para

borrarlo lo podemos hacer directamente del formulario seleccionndolo y
presionando la tecla delete o seleccionndolo desde la ventana "Outline" y
luego presionando la tecla delete
.
Ahora a los dos controles de tipo RadioButton definimos sus id (los llamaremos
r1
y
r2
respectivamente)
Cambiamos sus propiedades text por los textos "sumar" y "restar".
No olvidemos tambin cambiar los id de los controles EditText por et1 y et2
(igual que en el problema anterior)
Por ltimo agreguemos un botn y un TextView para mostrar el resultado
Inicializamos las propiedades del botn con los valores:
id : button1
text : operar
Y el tercer TextView con los valores:

id : tv3
text : resultado
Podemos controlar en la ventana "Outline" el id definido para cada control (tv1,

et1,
tv2,
et2,
radioGroup1,
r1,
r2,
button1,
tv3)
Tambin podemos observar de que clase es cada control visual y el texto de la
propiedad text para aquellos controles que tienen sentido su inicializacin.
Si nuestro problema requera ms de 3 RadioButton deberamos arrastrar

dentro del RadioGroup otros controles de tipo RadioButton que se encuentran
tambin en la pestaa de "Form Widgets"
Captura del evento clic del button e identifiacin del RadioButton seleccionado.
El cdigo fuente de la clase Proyecto003Activity es:
import
import
import
import
android.view.View;
android.widget.RadioButton;

{
private RadioButton r1,r2;

created. */
@Override
r1=(RadioButton)findViewById(R.id.r1);
}
el botn
public void operar(View view) {
if (r1.isChecked()==true) {
int suma=nro1+nro2;
tv3.setText(resu);
} else
int resta=nro1-nro2;
String
resu=String.valueOf(resta);
tv3.setText(resu);
}
}
}
Primero debemos enlazar el objeto button1 con el mtodo operar. Para esto
similar al problema anterior seleccionamos el control button1 y cambiamos la
propiedad OnClick por el valor operar (si no hacemos esto nunca se ejecutar
el mtodo operar de la clase Proyecto003Activity)
Como podemos ver el cdigo fuente es igual al problema anterior. Tenemos
dos objetos ms que debemos inicializar en el mtodo onCreate:
Las variables r1 y r2 son de la clase RadioButton y son necesarios en el

mtodo operar para verificar cual de los dos RadioButton estn seleccionados.
La clase RadioButton tiene un mtodo llamado isChecked que retorna true si
dicho elemento est seleccionado:
int suma=nro1+nro2;
tv3.setText(resu);
} else
String resu=String.valueOf(resta);
tv3.setText(resu);
}
}
Control CheckBox
El objetivo de este concepto es practicar lo visto hasta ahora e incorporar el
control visual CheckBox
Problema:

mensaje que solicite la carga de los valores. Disponer dos controles de tipo
CheckBox para seleccionar si queremos sumar y/o restar dichos valores.
Finalmente mediante un control de tipo Button efectuamos la operacin
respectiva. Mostramos el o los resultados en un TextView.
Lo nuevo en este problema es la insercin de dos objetos de la clase
CheckBox que se encuentra en la pestaa "FormWidgets":
Luego la interfaz grfica final para este problema y los nombres de los
controles los podemos ver en la ventana "Outline":
No olvidemos inicializar la propiedad OnClick del objeto button1 con el valor

"operar" (es el nombre del mtodo a ejecutarse cuando se presione el botn y
lo implementa la clase que hacemos)
Cdigo fuente:
import
import
import
import
import
android.os.Bundle;
android.view.View;
android.widget.CheckBox;
import android.widget.TextView;
{
private CheckBox checkBox1,checkBox2;
created. */
@Override
checkBox1=(CheckBox)findViewById(R.id.checkBox1);
}
el botn
String resu="";
if (checkBox1.isChecked()==true) {
int suma=nro1+nro2;
resu="La suma es: "+ suma;
}
resu=resu + " La resta es: "+ resta;
}
tv3.setText(resu);
}
}
Definimos dos objetos de la clase CheckBox como atributos de la clase:
private CheckBox checkBox1,checkBox2;
En el mtodo onCreate los inicializamos con los objetos definidos en el archivo

XML:
En el mtodo operar debemos definir dos if a la misma altura ya que los dos
controles de tipo CheckBox pueden estar seleccionados simultaneamente.
Definimos una variable de tipo String y la inicializamos con cadena vaca para
el caso en que los dos CheckBox no estn seleccionados:
String resu="";
int suma=nro1+nro2;
resu="La suma es: "+ suma;
}
resu=resu + " La resta es: "+ resta;
}
tv3.setText(resu);
Control Spinner
El objetivo de este concepto es practicar lo visto hasta ahora e incorporar el
control visual Spinner
El control Spinner muestra una lista de String y nos permite seleccionar uno de
ellos. Cuando se lo selecciona se abre y muestra todos sus elementos para
permitir seleccionar uno de ellos.
Problema:

mensaje que solicite la carga de los valores. Disponer un control de tipo
Spinner que permita seleccionar si queremos sumar, restar, multiplicar o dividir
dichos valores. Finalmente mediante un control de tipo Button efectuamos la

operacin respectiva. Mostramos el resultado en un TextView.
Lo nuevo en este problema es la insercin de un control de tipo Spinner que se
encuentra en la pestaa "FormWidgets":
Definimos la propiedad id con el valor spinner1.

En la siguiente imagen en la ventana "Outline" de Eclipse podemos observar
los objetos dispuestos en el formulario, sus Id, sus textos y de que clase son
cada uno:
No olvidemos inicializar la propiedad OnClick del objeto button1 con el valor

"operar" (dicho nombre es el mtodo que debemos implementar)
Cdigo fuente:
import
import
import
import
import
android.os.Bundle;
android.view.View;
android.widget.ArrayAdapter;
import android.widget.Spinner;
import android.widget.TextView;
{
private Spinner spinner1;
created. */
@Override
spinner1 = (Spinner)
findViewById(R.id.spinner1);
String
[]opciones={"sumar","restar","multiplicar","divid
ir"};
ArrayAdapter<String> adapter = new
ArrayAdapter<String>(this,android.R.layout.simple
_spinner_item, opciones);
spinner1.setAdapter(adapter);
}
el botn
String
selec=spinner1.getSelectedItem().toString();
if (selec.equals("sumar")) {
int suma=nro1+nro2;
tv3.setText(resu);
} else
if (selec.equals("restar")) {
String
resu=String.valueOf(resta);
tv3.setText(resu);
}
else
if (selec.equals("multiplicar"))
{
int multi=nro1*nro2;
String
resu=String.valueOf(multi);
tv3.setText(resu);
}
else
if (selec.equals("dividir"))
{
int divi=nro1/nro2;
String
resu=String.valueOf(divi);
tv3.setText(resu);
}
}
}
Definimos un objeto de la clase Spinner:
private Spinner spinner1;
En el mtodo onCreate obtenemos la referencia al control visual declarado en

el archivo XML:
spinner1=(Spinner)findViewById(R.id.spinner1);
Definimos un vector con la lista de String que mostrar el Spinner:

String []opciones={"sumar","restar","multiplicar","dividir"};
Definimos y creamos un objeto de la clase ArrayAdapter::

ArrayAdapter<String>
adapter
=
ArrayAdapter<String>(this,android.R.layout.simple_spinner_item,
opciones);
new
Al constructor le pasamos como primer parmetro la referencia de nuestro

Activity (this), el segundo parmetro indica el tipo de Spinner, pudiendo ser las
constantes:
android.R.layout.simple_spinner_item
android.R.layout.simple_spinner_dropdown_item
El tercer parmetro es la referencia del vector que se mostrar:

Luego llamamos al mtodo setAdapter de la clase Spinner pasando la
referencia del objeto de la clase ArrayAdapter que acabamos de crear:
spinner1.setAdapter(adapter);
En el mtodo operar que se ejecuta cuando presionamos el botn procedemos

a extraer el contenido seleccionado del control Spinner:
String selec=spinner1.getSelectedItem().toString();
Luego mediante una serie de if anidados verificamos si debemos sumar, restar,

multiplicar o dividir:
if (selec.equals("sumar")) {
int suma=nro1+nro2;
tv3.setText(resu);
} else
if (selec.equals("restar")) {
String resu=String.valueOf(resta);
tv3.setText(resu);
}
else
if (selec.equals("multiplicar")) {
int multi=nro1*nro2;
String resu=String.valueOf(multi);
tv3.setText(resu);
}
else
if (selec.equals("dividir")) {
int divi=nro1/nro2;
String resu=String.valueOf(divi);
tv3.setText(resu);
}
Control ImageButton
Hemos visto la creacin de objetos de la clase Button, ahora veremos otra
clase muy similar a la anterior llamada ImageButton que tiene la misma filosofa
de manejo con la diferencia que puede mostrar una imagen en su superficie.
Problema:
Disponer un objeto de la clase ImageButton que muestre una imagen de un

telfono. Cuando se presione mostrar en un control TextView el mensaje
"Llamando".
Primero crearemos un proyecto llamado proyecto007 y luego debemos buscar
una imagen en formato png que represente un telefono de 50*50 pxeles.
Nombre
del
archivo:
telefono.png
Ahora copiamos el archivo a la carpeta de recursos de nuestro proyecto :
res\drawable-mdpi
Desde el Eclipse en la ventana "Package Explorer" navegamos hasta la
carpeta res y entramos al directorio drawable-mdpi y vemos que todava no
est el archivo que acabamos de copiar. Para que se actualice el proyecto
presionamos el botn derecho del mouse sobre esta carpeta y seleccionamos
la opcin "Refresh":
Vemos que se actualiz el contenido de la carpeta y aparece la imagen que

copiamos previamente.
Ahora insertaremos el objeto de la clase ImageButton en el formulario de
nuestra aplicacin. La clase ImageButton se encuentra en la pestaa "Image &
Media":
Aparece un dilogo de donde seleccionamos el archivo telefono. Luego de esto

podemos ver que la superficie del objeto de la clase ImageButton muestra la
imagen que almacenamos previamente en la carpeta de res.
Si queremos cambiar el archivo a mostrar debemos modificar la propiedad src
(aparece nuevamente el dilogo que nos permite seleccionar la imagen)
Inicializamos la propiedad ID con el nombre bi1
Agreguemos un TextView a nuestra aplicacin y configuremos sus propiedades
ID (con tv1) y text. Luego la interfaz visual debe ser similar a:
Cdigo fuente:
import
import
import
import
android.os.Bundle;
android.view.View;

{
private ImageButton ib1;
created. */
@Override
}
el ImageButton
public void llamar(View view) {
tv1.setText("Llamando");
}
}
Definimos los dos atributos:
TextView tv1;
Enlazamos el control definido en el archivo XML y la variable de java:

Implementamos el mtodo que se ejecutar cuando se presione el el objeto de

la clase ImageButton:
public void llamar(View view) {
tv1.setText("Llamando");
}
No olvidemos inicializar la propiedad OnClick del objeto ib1 con el nombre del
mtodo "llamar" (recordemos que esto lo hacemos presionando el botn
derecho del mouse sobre la imagen del objeto de la clase ImageButton y desde
la opcin properties accedemos a la propiedad OnClick)
Comentarios extras de este control.
Cuando copiamos el archivo lo hicimos a la carpeta:

drawable-mdpi
Pero vimos que hay otras dos carpetas con nombres similares:
drawable-ldpi
drawable-hdpi
El objetivo de estas otras dos carpetas es guardar las mismas imgenes pero
con una resolucin mayor si la guardamos en drawable-hdpi y con una
resolucin menor al guardarla en drawable-ldpi.
Esto se hace si queremos que nuestra aplicacin sea ms flexible si se ejecuta
en un celular, en un tablet, en un televisor etc.
Debemos tener en cuenta estos tamaos:
En la carpeta res/drawable-mdpi/
(guardamos la imagen con el tamao original)
En la carpeta res/drawable-ldpi/
(guardamos la imagen con el tamao del 75% con respecto al de la carpeta
drawable-mdpi)
En la carpeta res/drawable-hdpi/
(guardamos la imagen con el tamao del 150% con respecto al de la carpeta
drawable-mdpi)
Lanzar un segundo "Activity"

Hasta ahora todos los programas han tenido una sola ventana (Activity)
Es muy comn que una aplicacin tenga ms de una ventana. Para
implementar esto en Android debemos plantear una segunda clase que
tambin herede de la clase Activity (tengamos en cuenta que cuando
utilizamos el plugin de Eclipse para Android automticamente cuando creamos
un proyecto nos crea el archivo XML y java de la primer Activity)
Vamos a ver en este concepto los pasos que debemos dar para crear otro
Activity y como activarlo desde el Activity principal.
Problema:
Confeccionar un programa que muestre en la ventana principal un botn que al

ser presionado muestre otra ventana (Activity) mostrando un TextView con el
nombre del programador de la aplicacin y un botn para cerrar la ventana.
1 - Primero creamos un nuevo proyecto que lo llamaremos proyecto008 y en la
ventana principal creamos la siguiente interfaz:
Es decir que nosotros queremos que cuando se presione el botn "Acerca De"
nos abra otra ventana (Activity) y nos muestre el nombre del programador.
2 - Ahora tenemos que crear el segundo Activity. Crearemos primero el archivo
XML. Presionamos el botn derecho sobre la carpeta layout y seleccionaremos
la
opcin
New
->
Android
XML
File
Aqu tenemos que definir el nombre del archivo XML (debe estar en
minsculas), lo llamaremos acercade:
Implementamos ahora la interfaz visual de esta segunda ventana (Activity)

disponiendo un objeto de la clase TextView donde mostramos el nombre del
autor de este programa y un Button para cerrar la ventana.
3 - Tenemos ahora que crear el archivo Java donde dispondremos la

funcionalidad de la segunda ventana (Activity)
Creamos una nueva clase al proyecto desde el men contextual(presionamos
el botn derecho del mouse sobre el paquete androidya.proyecto008):
Al nombre de la clase la llamamos AcercaDe y debemos especificar que

hereda de la clase Activity:
Ahora tenemos que modificar el archivo Java generado con esto:
public class AcercaDe extends Activity {
created. */
@Override
setContentView(R.layout.acercade);
}
}
Como podemos ver la clase AcercaDe hereda de la clase Activity e implementa
el mtodo onCreate para enlazar el archivo XML que creamos anteriormente.
4 - Otro paso fundamental es registrar el Activity en el archivo
"AndroidManifest.xml" que se encuentra en la raiz principal del proyecto.
Seleccionamos el archivo y activamos la pestaa : "Application", presionamos
el botn "add" y seleccionamos "Activity":
Por ltimo seleccionamos en "Application Nodes" la actividad creada y

definimos la propiedad Name con el nombre de la clase que la implementa (en
nuestro
caso
se
llama
AcercaDe):
5 - Ahora implementaremos la funcionalidad en la actividad (Activity) principal

para que se active la segunda ventana.
Inicializamos la propiedad OnClick del objeto de la clase Button con el valor
"lanzar", este es el mtodo que se ejecutar cuando se presione.
El cdigo fuente de la actividad principal queda:
import
import
import
import
android.content.Intent;
android.os.Bundle;
android.view.View;

{
created. */
@Override
}
public void lanzar(View view) {
Intent i = new Intent(this,
AcercaDe.class );
startActivity(i);
}
}
En el mtodo lanzar creamos un objeto de la clase Intent y le pasamos como
parmetros la referencia del objeto de esta clase (this) y la referencia del otro
Activity
(Acerca.class)
Llamamos posteriormente al mtodo startActivity pasando el objeto de la clase
Intent (con esto ya tenemos en pantalla la ventana del segundo Activity:
public void lanzar(View view) {
Intent i = new Intent(this, AcercaDe.class );
startActivity(i);
}
Si ejecutamos el programa podemos ver que cuando presionamos el botn

"Acerca De" aparece la segunda ventana donde se muestra el TextView con el
valor "Autor de este programa: Diego" y un botn con el texto "Finalizar" (si
presionamos este botn no sucede nada, esto debido a que no hemos
asociado ningn evento a dicho botn)
6 - Debemos codificar el evento OnClick de la segunda actividad.
Seleccionemos el botn "Finalizar" y definamos en la propiedad OnClick el
nombre de mtodo que se ejecutar al presionarse el botn (en nuestro caso lo
llamaremos finalizar") :
El cdigo fuente de la actividad AcercaDe queda:
import android.view.View;
public class AcercaDe extends Activity {
created. */
@Override
setContentView(R.layout.acercade);
}
public void cerrar(View view) {
finish();
}
}
Cuando se presiona el botn finalizar llamando al mtodo finish() que tiene por
objetivo liberar el espacio de memoria de esta actividad y pedir que se active la
actividad anterior.
Ahora nuestro programa est funcionando completamente:
Primer Activity:
Segundo Activity:
Ahora ya tenemos el programa funcionando en forma completa.
Problema propuesto
1. Realizar un programa que contenga dos Activity. En el primero que
solicite el ingreso de una clave (control Password) Si ingresa la clave
"abc123" activar el segundo Activity mostrando en un TextView un
mensaje de bienvenida (mostrar en un TextView si se ingrese la clave
incorrecta).
Llamar
al
proyecto:
proyecto009.
En tiempo de ejecucin los dos Activity deben mostrarse algo similar a
esto:
Lanzar un segundo "Activity" y pasar parmetros.

Hemos visto en el concepto anterior que un programa puede tener ms de una
ventana representando cada ventana con una clase que hereda de Activity.
Una situacin muy comn es que la primer ventana necesite enviar datos a la
segunda para que a partir de estos proceda a efectuar una accin.
Problema:
Confeccionar un programa que solicite el ingrese de una direccin de un sitio

web y seguidamente abrir una segunda ventana que muestre dicha pgina.
Para resolver este problema utilizaremos el control visual WebView que nos
permite mostrar el contenido de un sitio web.
Crearemos un nuevo proyecto llamado proyecto010 y lo almacenaremos en el
package name: androidya.proyecto010.
1 - Nuestro primer Activity tendr la siguiente interfaz visual (ver controles y ID
de
los
controles):
Tenemos un control de tipo TextView (tv1), otro de tipo EditText y finalmente

otro de tipo Button (button1) debemos inicializar las propiedades de cada uno
de estos tres objetos.
El cdigo fuente de esta Activity es:
import
import
import
import
import
android.os.Bundle;
android.view.View;

{
private EditText et1;

created. */
@Override
}
public void ejecutar(View view) {
Intent i = new Intent(this,
Actividad2.class );
i.putExtra("direccion",
et1.getText().toString());
startActivity(i);
}
}
Como podemos ver la diferencia con el concepto anterior es que llamamos al
mtodo putExtra de la clase Intent. Tiene dos parmetros de tipo String, en el
primero indicamos el nombre del dato y en el segundo el valor del dato:
public void ejecutar(View view) {
Intent i = new Intent(this, Actividad2.class );
i.putExtra("direccion", et1.getText().toString());
startActivity(i);
}
La segunda interfaz visual (recordemos que debemos presionar el botn

derecho sobre la carpeta layout y seleccionar la opcin New -> Android XML
File) la llamaremos actividad2.xml:
En esta interfaz disponemos primero un control de tipo Button (button1) y un

objeto de la clase WebView (se encuentra en la pestaa "Composite") y lo
dejamos con el ID por defecto llamado webView1
Tenemos que crear el archivo Java donde dispondremos la funcionalidad de la
segunda
ventana
(Activity)
Creamos una nueva clase al proyecto desde el men contextual(presionamos
el botn derecho del mouse sobre el paquete androidya.proyecto010)
Al nombre de la clase la llamamos Actividad2 y debemos especificar que
hereda
de
la
clase
Activity
Ahora tenemos que modificar el archivo Java generado con esto:
import
import
import
import
android.os.Bundle;
android.view.View;
android.webkit.WebView;
public class Actividad2 extends Activity {
private WebView webView1;

@Override
public void onCreate(Bundle b) {
super.onCreate(b);
setContentView(R.layout.actividad2);
webView1=(WebView)findViewById(R.id.webView1);
Bundle bundle=getIntent().getExtras();
webView1.loadUrl("http://"+bundle.getString("dire
ccion"));
}
public void finalizar(View view) {
finish();
}
}
En esta clase definimos una variable de tipo Bundle y la inicializamos llamando
al mtodo getExtras() de la clase Intent (esto lo hacemos para recuperar el o
los parmetros que envi la otra actividad (Activity)):
Bundle bundle=getIntent().getExtras();
webView1.loadUrl("http://"+bundle.getString("direccion"));
El mtodo loadUrl de la clase WebView permite visualizar el contenido de un

sitio web.
Otro paso fundamental es registrar el Activity en el archivo
"AndroidManifest.xml" que se encuentra en la raiz principal del proyecto.
Seleccionamos el archivo y activamos la pestaa : "Application", presionamos
el
botn
"add"
y
seleccionamos
"Activity".
Por ltimo seleccionamos en "Application Nodes" la actividad creada y
definimos la propiedad Name con el nombre de la clase que la implementa (en
nuestro caso se llama Actividad2)
Como nuestra aplicacin debe acceder a internet debemos hacer otra
configuracin en el archivo "AndroidManifest.xml", debemos ir a la pestaa
"Permissions" presionar el botn "Add" y seleccionar "Uses Permissions":
Luego fijar en la propiedad name el valor android.permission.INTERNET

Ahora nuestro programa debera estar funcionando completamente.
La primer ventana debera ser algo similar a esto:
La segunda ventana debera ser algo similar a esto otro:
Almacenamiento de datos en un archivo de texto en la memoria

interna.
Otra posibilidad de almacenar datos en nuestro dispositivo Android es el
empleo de un archivo de texto que se almacenar en el almacenamiento
interno del equipo (la otro posibilidad es almacenarlo en una tarjeta SD Card)
Problema:
Confeccionar un programa que permita almacenar notas en un control EditText

y cuando se presione un botn almacenar los datos del EditText en un archivo
de
texto
llamado
"notas.txt".
Cada vez que se ingrese al programa verificar si existe el archivo de textos
"notas.txt" proceder a su lectura y almacenamiento de datos en el EditText.
Crear un proyecto en Eclipse de tipo "Android Project" y definir como nombre:
proyecto013 y localizarlo en el paquete androidya.proyecto013.
La interfaz visual, los controles y sus ID son los siguientes:
El cdigo fuente de la aplicacin:
import
import
import
import
java.io.BufferedReader;
java.io.IOException;
java.io.InputStreamReader;
java.io.OutputStreamWriter;
import android.widget.EditText;
import android.widget.Toast;
{
private EditText et1;
created. */
@Override
String []archivos=fileList();
if (existe(archivos,"notas.txt"))
try {
InputStreamReader archivo=new
InputStreamReader(openFileInput("notas.txt"));
BufferedReader br=new
BufferedReader(archivo);
String linea=br.readLine();
String todo="";
while (linea!=null)
{
todo=todo+linea+"\n";
linea=br.readLine();
}
br.close();
archivo.close();
et1.setText(todo);
} catch (IOException e)
{
}
}
private boolean existe(String[]
archivos,String archbusca)
{
for(int f=0;f<archivos.length;f++)
if (archbusca.equals(archivos[f]))
return true;
return false;
}
public void grabar(View v) {
try {
OutputStreamWriter archivo = new
OutputStreamWriter(openFileOutput("notas.txt",Act
ivity.MODE_PRIVATE));
archivo.write(et1.getText().toString());
archivo.flush();
archivo.close();
}catch (IOException e)
{
}
Toast t=Toast.makeText(this,"Los datos
fueron grabados", Toast.LENGTH_SHORT);
t.show();
finish();
}
}
Veamos primero como grabamos datos en un archivo de texto. Esto se hace
en el mtodo grabar que se ejecuta cuando presionamos el botn "grabar"
(recordemos de inicializar la propiedad "OnClick" del botn):
try {
OutputStreamWriter
archivo
=
new
OutputStreamWriter(openFileOutput("notas.txt",Activity.MODE_PRIVATE));
Creamos un objeto de la clase OutputStreamWriter y al constructor de dicha

clase le enviamos el dato que retorna el mtodo openFileOutput propio de la
clase Activity que le pasamos como parmetro el nombre del archivo de texto y
el modo de apertura.
Seguidamente si el archivo se cre correctamente procedemos a llamar al
mtodo write y le pasamos el String a grabar, en este caso extraemos los datos
del EditText:
archivo.write(et1.getText().toString());
Luego de grabar con el mtodo write llamamos al mtodo flush para que
vuelque todos los datos que pueden haber quedado en el buffer y procedemos
al cerrado del archivo:
archivo.flush();
archivo.close();
Todo esto est cerrado en un try/catch para verificar si sucede algn error en la
apertura del archivo.
Finalmente mostramos un mensaje temporal en pantalla utilizando la clase
Toast:
Toast
t=Toast.makeText(this,"Los
Toast.LENGTH_SHORT);
t.show();
finish();
datos
fueron
grabados",
Para crear un objeto de la clase Toast llamamos al mtodo makeText de la

clase Toast y le pasamos la referencia del Activity actual, el String a mostrar y
el tiempo de duracin del mensaje. Con el objeto devuelto por el mtodo
makeText procedemos a llamar seguidamente al mtodo show para que se
muestre el mensaje.
Es comn llamar al mtodo show de la clase Toast en una sola lnea como
esta:
Toast.makeText(this,"Los
Toast.LENGTH_SHORT).show();
datos
fueron
grabados",
El mtodo onCreate tiene por objetivo verificar si existe el archivo de texto,

proceder a su lectura y mostrar su contenido en el EditText.
Primero obtenemos la lista de todos los archivos creados por la Activity. En
nuestro ejemplo puede ser cero o uno:
String []archivos=fileList();
Llamamos a un mtodo que verifica si en el vector de tipo String existe el

archivo "notas.txt":
if (existe(archivos,"notas.txt"))
En el caso que me retorne true procedemos a crear un objeto de la clase

InputStreamReader y al constructor de dicha clase le pasamos el dato devuelto
por el mtodo openFileInput:
InputStreamReader
InputStreamReader(openFileInput("notas.txt"));
archivo=new
Creamos un objeto de la clase BufferedReader y le pasamos al constructor la

referencia del objeto de la clase InputStreamReader:
BufferedReader br=new BufferedReader(archivo);
Leemos la primer lnea del archivo de texto:

Inicializamos un String vaco:
String todo="";
Mientras el mtodo readLine de la clase BufferedReader devuelva un String:

while (linea!=null)
{
Lo concatenamos al String junto a un salto de lnea:

Leemos la prxima lnea:

}
Llamamos al mtodo
InputStreamReader:
close
de
la
clase
BufferedReader
al
del
br.close();
archivo.close();
Cargamos el EditText con el contenido del String que contiene todos los datos
del archivo de texto:
et1.setText(todo);
El mtodo existe llega un vector de tipo String y otro String a buscar. Dentro de
un for verificamos el String a buscar con cada uno de los String del vector, si lo
encontramos retornamos true. Si recorre todo el for sin encontrarlo fuera del for
retornamos false:
private boolean existe(String[] archivos,String archbusca)
{
for(int f=0;f<archivos.length;f++)
if (archbusca.equals(archivos[f]))
return true;
return false;
}
Almacenamiento de datos en un archivo de texto localizado en una

tarjeta SD
En el concepto anterior vimos como crear y leer un archivo de texto en la
memoria interna del equipo Android. En algunas situaciones podra ser til
almacenar los datos en una tarjeta SD, esto debido a su mayor capacidad o la
facilidad de compartir los archivos con otras personas entregando la tarjeta SD.
Problema:
Confeccionar un programa que permita ingresar el nombre de un archivo y el

contenido. Permitir grabar los datos ingresados al presionar un botn. Disponer
un segundo botn que permita recuperar los datos del archivo de texto.
Hacer que los archivos se graben en una tarjeta SD.
La interfaz visual a implementar es la siguiente:
El primer paso es modificar el archivo AndroidManifest.xml para permitir el

acceso a la tarjeta SD desde nuestra aplicacin esto lo hacemos desde el
editor visual del archivo AndroidManifest.xml:
Debemos presionar el botn "Add" seleccionar "Uses Permision" y luego en

name seleccionar "android.permission.WRITE_EXTERNAL_STORAGE".
El cdigo fuente es:
import
import
import
import
import
import
import
java.io.BufferedReader;
java.io.File;
java.io.FileInputStream;
java.io.FileOutputStream;
java.io.IOException;
java.io.InputStreamReader;
java.io.OutputStreamWriter;
import
import
import
import
import
import
android.os.Bundle;
android.os.Environment;
android.view.View;
android.widget.Toast;

{
EditText et1;
EditText et2;
created. */
@Override
et1=(EditText)findViewById(R.id.editText1);
}
String nomarchivo =
et1.getText().toString();
String
contenido=et2.getText().toString();
try
{
File tarjeta =
Environment.getExternalStorageDirectory();
File file = new
File(tarjeta.getAbsolutePath(), nomarchivo);
OutputStreamWriter osw =new
OutputStreamWriter(new FileOutputStream(file));
osw.write(contenido);
osw.flush();
osw.close();
Toast.makeText(this,"Los datos fueron
grabados
correctamente",Toast.LENGTH_SHORT).show();
et1.setText("");
et2.setText("");
}
catch (IOException ioe)
{
}
}
public void recuperar(View v) {
String nomarchivo =
et1.getText().toString();
File tarjeta =
Environment.getExternalStorageDirectory();
File file = new
File(tarjeta.getAbsolutePath(), nomarchivo);
try {
FileInputStream fIn = new
FileInputStream(file);
InputStreamReader archivo=new
InputStreamReader(fIn);
BufferedReader br=new
BufferedReader(archivo);
String todo="";
while (linea!=null)
{
}
br.close();
archivo.close();
et2.setText(todo);
{
}
}
}
El mtodo para grabar los datos en un archivo de texto localizado en una
tarjeta SD comienza obteniendo el directorio raiz de la tarjeta a travs del
mtodo getExternalStorageDirectory(), el mismo retorna un objeto de la clase
File.
String nomarchivo = et1.getText().toString();
String contenido=et2.getText().toString();
try
{
File tarjeta = Environment.getExternalStorageDirectory();
Creamos un nuevo objeto de la clase File indicando el camino de la unidad SD

y el nombre del archivo a crear:
File file = new File(tarjeta.getAbsolutePath(), nomarchivo);
Por ltimo similar al acceso de un archivo interno creamos un objeto de la clase

OutputStreamWriter:
OutputStreamWriter
FileOutputStream(file));
Grabamos el contenido del EditText:

osw.write(contenido);
Cerramos el archivo:
osw.flush();
osw.close();
osw
=new
OutputStreamWriter(new
Toast.makeText(this,"Los
datos
correctamente",Toast.LENGTH_SHORT).show();
et1.setText("");
et2.setText("");
}
catch (IOException ioe)
{
}
}
fueron
grabados
Para la lectura del archivo nuevamente obtenemos la referencia de la tarjeta

SD para obtener el path de la unidad de almacenamiento, el resto del algoritmo
es similar al visto con un archivo interno:
public void recuperar(View v) {
String nomarchivo = et1.getText().toString();
File tarjeta = Environment.getExternalStorageDirectory();
File file = new File(tarjeta.getAbsolutePath(), nomarchivo);
try {
FileInputStream fIn = new FileInputStream(file);
InputStreamReader archivo=new InputStreamReader(fIn);
BufferedReader br=new BufferedReader(archivo);
String todo="";
while (linea!=null)
{
}
br.close();
archivo.close();
et2.setText(todo);
{
}
}
Almacenamiento en una base de datos SQLite

Hemos visto hasta ahora dos modos de almacenar datos en forma permanente
(archivos de texto y la clase SharedPreferences), ahora veremos otra
herramienta nativa de Android para almacenar datos en una base de datos
llamada SQLite.
SQLite es una base de datos Open Source, es muy popular en muchos
dispositivos pequeos, como Android.
Las ventajas que presenta utilizar SQLite es que no requiere configuracin, no
tiene un servidor de base de datos ejecutndose en un proceso separado y es
relativamente simple su empleo.
Problema:
Confeccionar un programa que permita almacenar los datos de votantes de

una eleccin. Crear la tabla votantes y definir los campos dni (documento de
identidad), nombre del votante, colegio donde vota y nmero de mesa donde
vota.
El programa debe permitir:
1
2
3
4
Carga de personas.
Consulta por el dni (para saber donde vota)
Borrado de personas
Modificacin de datos.
Primero implementamos una interfaz visual similar a esta:
Lo primero que haremos es crear una clase que herede de SQLiteOpenHelper.

Esta clase nos permite crear la base de datos y actualizar la estructura de
tablas y datos iniciales.
Debemos implementar el constructor y sobreescribir los mtodos onCreate y
onUpgrade.
El mtodo onCreate se le llama cuando la base de datos se crea por primera

vez. Aqu es donde se define la estructura de las tablas y se cargan
eventualmente los datos iniciales
En el mtodo onUpgrade se llama cuando la base de datos debe ser
actualizada. Tiene por objetivo eliminar tablas, aadir tablas, o hacer cualquier
otra cosa que necesita para actualizarse.
En nuestro problema implementaremos una nueva clase llamada
AdminSQLiteOpenHelper que herede de la clase SQLiteOpenHelper:
import android.content.Context;
import android.database.sqlite.SQLiteDatabase;
import
android.database.sqlite.SQLiteDatabase.CursorFact
ory;
import android.database.sqlite.SQLiteOpenHelper;
public class AdminSQLiteOpenHelper extends
SQLiteOpenHelper {
public AdminSQLiteOpenHelper(Context
context, String nombre, CursorFactory factory,
int version) {
super(context, nombre, factory,
version);
}
@Override
public void onCreate(SQLiteDatabase db) {
db.execSQL("create table votantes(dni
integer primary key, nombre text, colegio text,
nromesa integer)");
}
@Override
public void onUpgrade(SQLiteDatabase db, int
versionAnte, int versionNue) {
db.execSQL("drop table if exists
votantes");
db.execSQL("create table votantes(dni

integer primary key, nombre text, colegio text,
nromesa integer)");
}
}
En el constructor solo llamamos al constructor de la clase padre pasando los
datos que llegan en los parmetros:
public AdminSQLiteOpenHelper(Context context,
CursorFactory factory, int version) {
super(context, nombre, factory, version);
}
String
nombre,
En el mtodo onCreate procedemos a crear la tabla votantes con los cuatro

campos respectivos y definiendo el campo dni como primary key:
public void onCreate(SQLiteDatabase db) {
db.execSQL("create table votantes(dni integer primary key,
nombre text, colegio text, nromesa integer)");
}
En el mtodo onUpgrade procedemos a borrar la tabla votantes y crear

nuevamente la tabla (en este caso con la misma estructura pero podra ser otra
en un caso ms real:
public
versionNue) {
void
onUpgrade(SQLiteDatabase
db,
int
versionAnte,
int
db.execSQL("drop table if exists votantes");

db.execSQL("create table votantes(dni integer primary key,
nombre text, colegio text, nromesa integer)");
}
Ahora veamos la otra clase que implementar las altas, bajas, modificaciones y
consultas:
import
import
import
import
import
import
import
import
android.content.ContentValues;
android.database.Cursor;
android.database.sqlite.SQLiteDatabase;
android.os.Bundle;
android.view.View;
android.widget.Toast;

{
private EditText et1,et2,et3,et4;

created. */
@Override
}
public void alta(View v) {
AdminSQLiteOpenHelper admin=new
AdminSQLiteOpenHelper(this, "administracion",
null, 1);
SQLiteDatabase
bd=admin.getWritableDatabase();
String dni=et1.getText().toString();
String nombre=et2.getText().toString();
String colegio=et3.getText().toString();
String nromesa=et4.getText().toString();
ContentValues registro=new
ContentValues();
registro.put("dni",dni );
registro.put("nombre",nombre );
registro.put("colegio",colegio );
registro.put("nromesa",nromesa );
bd.insert("votantes", null, registro);
bd.close();
et1.setText("");
et2.setText("");
et3.setText("");
et4.setText("");
Toast.makeText(this, "Se cargaron los
datos de la persona", Toast.LENGTH_SHORT).show();
}
public void consulta(View v) {
null, 1);
SQLiteDatabase
Cursor fila=bd.rawQuery("select
nombre,colegio,nromesa from votantes where
dni="+dni+"",null);
if (fila.moveToFirst())
{
et2.setText(fila.getString(0));
}
else
Toast.makeText(this, "No existe una
persona con dicho dni",
bd.close();
}
public void baja(View v) {
null, 1);
SQLiteDatabase
int cant=bd.delete("votantes",
"dni="+dni+"",null);
bd.close();
et1.setText("");
et2.setText("");
et3.setText("");
et4.setText("");
if (cant==1)
Toast.makeText(this, "Se borr la
persona con dicho documento",
else
Toast.makeText(this, "No existe una
}
public void modificacion(View v) {
null, 1);
SQLiteDatabase
ContentValues registro=new
ContentValues();
registro.put("nombre",nombre);
registro.put("colegio",colegio);
registro.put("nromesa",nromesa);
int cant = bd.update("votantes",
registro, "dni="+dni, null);
bd.close();
if (cant==1)
Toast.makeText(this, "se modificaron

los datos", Toast.LENGTH_SHORT).show();
else
Toast.makeText(this, "no existe una
}
}
Como en problemas anteriores definimos los cuatro EditText como atributos y
en el mtodo onCreate obtenemos la referencia de los mismos:
public class Proyecto015Activity extends Activity {
private EditText et1,et2,et3,et4;
/** Called when the activity is first created. */
@Override
}
1 - Alta de datos.
Cuando se presiona el botn alta se ejecuta el mtodo "alta" recordemos
inicializar la propiedad "OnClick" del botn desde la ventana de visualizacin
del
archivo
XML.
Lo primero que hacemos en este mtodo es crear un objeto de la clase que
planteamos anteriormente y le pasamos al constructor this (referencia del
Activity actual), "administracion" (es el nombre de la base de datos que
crearemos en el caso que no exista) luego pasamos null y un uno indicando
que es la primer versin de la base de datos (en caso que cambiemos la
estructura o agreguemos tablas por ejemplo podemos pasar un dos en lugar de
un uno para que se ejecute el mtodo onUpgrade donde indicamos la nuestra
estructura de la base de datos)
Luego de crear un objeto de la clase AdminSqLiteOpenHelper procedemos a
crear un objeto de la clase SQLiteDataBase llamando al mtodo
getWritableDatabase (la base de datos se abre en modo lectura y escritura).
Creamos un objeto de la clase ContentValues y mediante el mtodo put
inicializamos
todos
tos
campos
a
cargar.
Seguidamente llamamos al mtodo insert de la clase SQLiteDatabase pasando
en el primer parmetro el nombre de la tabla, como segundo parmetro un null
y por ltimo el objeto de la clase ContentValues ya inicializado (este mtodo es
el que provoca que se inserte una nueva fila en la tabla votantes en la base de
datos
llamada
administracion)
Borramos seguidamente los EditText y mostramos un mensaje para que

conozca el operador que el alta de datos se efectu en forma correcta:
public void alta(View v) {
AdminSQLiteOpenHelper
admin=new
AdminSQLiteOpenHelper(this,
"administracion", null, 1);
SQLiteDatabase bd=admin.getWritableDatabase();
ContentValues registro=new ContentValues();
registro.put("dni",dni );
registro.put("nombre",nombre );
registro.put("colegio",colegio );
registro.put("nromesa",nromesa );
bd.insert("votantes", null, registro);
bd.close();
et1.setText("");
et2.setText("");
et3.setText("");
et4.setText("");
Toast.makeText(this, "Se cargaron los datos de la persona",
}
2 - Consulta de datos.
Cuando se presiona el botn "Consulta por DNI" se ejecuta el mtodo consulta:
public void consulta(View v) {
admin=new
Cursor fila=bd.rawQuery("select nombre,colegio,nromesa
from
votantes where dni="+dni+"",null);
if (fila.moveToFirst())
{
}
else
Toast.makeText(this, "No existe una persona con dicho dni",
bd.close();
}
En el mtodo consulta lo primero que hacemos es crear un objeto de la clase

AdminSQLiteOpenHelper y obtener una referencia de la base de datos
llamando
al
mtodo
getWritableDatabase.
Seguidamente definimos una variable de la clase Cursor y la inicializamos con
el valor devuelto por el mtodo llamado rawQuery.
La clase Cursos almacena en este caso una fila o cero filas (una en caso que
hayamos ingresado un dni existente en la tabla votantes), llamamos al mtodo
moveToFirst() de la clase Cursos y retorna true en caso de existir una persona

con el dni ingresado, en caso contrario retorna cero.
Para recuperar los datos propiamente dichos que queremos consultar
llamamos al mtodo getString y le pasamos la posicin del campo a recuperar
(comienza a numerarse en cero, en este ejemplo la columna cero representa el
campo nombre, la columna 1 representa el campo colegio y la columna 2
representa el campo nromesa)
3 - Baja o borrado de datos.
Para borrar uno o ms registros la clase SQLiteDatabase tiene un mtodo que
le pasamos en el primer parmetro el nombre de la tabla y en el segundo la
condicin que debe cumplirse para que se borre la fila de la tabla. El mtodo
delete retorna un entero que indica la cantidad de registros borrados:
public void baja(View v) {
admin=new
int cant=bd.delete("votantes", "dni="+dni+"",null);
bd.close();
et1.setText("");
et2.setText("");
et3.setText("");
et4.setText("");
if (cant==1)
Toast.makeText(this, "Se borr la persona con dicho documento",
else
Toast.makeText(this, "No existe una persona con dicho
documento", Toast.LENGTH_SHORT).show();
}
4 - Modificacin de datos.
En la modificacin de datos debemos crear un objeto de la clase
ContentValues y mediante el mtodo put almacenar los valores para cada
campo que ser modificado. Luego se llama al mtodo update de la clase
SQLiteDatabase pasando el nombre de la tabla, el objeto de la clase
ContentValues y la condicin del where (el cuanto parmetro en este ejemplo
no se lo emplea)
public void modificacion(View v) {
admin=new
ContentValues registro=new ContentValues();
registro.put("nombre",nombre);
registro.put("colegio",colegio);
registro.put("nromesa",nromesa);
int cant = bd.update("votantes", registro, "dni="+dni, null);
bd.close();
if (cant==1)
Toast.makeText(this,
"se
modificaron
los
datos",
else
Toast.makeText(this, "no existe una persona con dicho
documento", Toast.LENGTH_SHORT).show();
}
Ventana de propiedades (Properties)

Hasta ahora siempre que queremos modificar propiedades de un objeto
debemos presionar el botn derecho del mouse y mediante el men contextual
proceder a accederla y modificarla:
Otra forma de acceder a estas propiedades es la apertura de la ventana de

properties, para esto desde el men de Eclipse procedemos a seleccionar la
opcin: Window -> Show View -> Other...:
Ahora seleccionamos en el dilogo siguiente en el cuadro General el cono de

Properties:
Ahora cuando disponemos objetos sobre el formulario o lienzo de nuestra

aplicacin podemos ver todas las propiedades del objetos seleccionado y
modificarlas desde esta ventana:
Por ejemplo si queremos definir la propiedad On Click de un objeto Button

debemos seleccionarlo y en la ventana de propiedades cargamos el valor para
dicha propiedad:
Layout (TableLayout)
El Layout de tipo TableLayout agrupa componentes en filas y columnas. Un
TableLayout contiene un conjunto de componentes de tipo TableRow que es el
que agrupa componentes visuales por cada fila (cada fila puede tener distinta
cantidad de componentes visuales)
Cuando disponemos un control de Layouts de tipo TableLayout
automticamente crea cuatro componentes de tipo TableRow que los podemos
ver en la ventana "Outline". Podemos borrar o agregar componentes de tipo
TableRow segn las necesidades de nuestro TableLayout:
Luego de borrar un control de tipo TableRow y agregar componentes de tipo

Button la interfaz visual queda como sigue:
Otra propiedad que nos puede ser til inicializar en los controles que se
disponen dentro de un TableLayout es layout_span. Esta propiedad permite
que un control se expanda ms de una celda.
En el siguiente ejemplo el objeto de la clase Button de la segunda fila hemos
dispuesto la propiedad layout_span con el valor 2:
Si la propiedad no aparece en la ventana "Properties" cuando seleccionamos el

objeto debemos entrar al archivo XML y agregar manualmente dicha
propiedad:
Layout (RelativeLayout)
Hay varias posibilidades cuando empleamos el RelativeLayout. Primero
podemos alinear un control con respecto al Layout que lo contiene. Para probar
esto dispondremos un control de tipo RelativeLayout y fijaremos la propiedad
Layout_weight con el valor 1 (esto hace que el RelativeLayout ocupe
completamente la pantalla) Luego dispondremos un botn en cada vrtice y
veremos que propiedades son afectadas e inicializadas:
Como podemos ver cada control que agregamos se inicializan alguna de las
propiedades:
alignParentLeft
alignParentRight
alignParentTop
alignParentBottom
centerHorizontal
centerVertical
centerInParent
Con este tipo de layout podemos disponer un control en forma relativa a otro
control que haya dentro del RelativeLayout. Veamos un ejemplo:
En este ejemplo hemos dispuesto el segundo botn debajo (below) del botn 1
y alineado a la izquierda (luego si desplazamos el botn 1 se desplazar el
botn 2)
La posicin relativa con respecto a otro control puede ser:
above (por encima)
below (debajo)
toLeftOf (a la izquierda de)
toRightOf (a la derecha)
Layout (FrameLayout)
El control de tipo FrameLayout dispone dentro del contenedor todos los
controles visuales alineados al vrtice superior izquierdo. Es decir si
disponemos dos o ms controles los mismos se apilan.
Por ejemplo si disponemos dentro de un FrameLayout un ImageView y un

Button luego el botn se superpone a la imagen:
Otra aplicacin del control FrameLayout es disponer una serie de controles

visuales no visibles e ir alternando cual se hace visible.
Problema:
Disponer un ImageView y un Button dentro de un layout FrameLayout. Cuando

se inicia la aplicacin mostrar solo el botn y al ser presionado ocultar el botn
y hacer visible la imagen que muestra el ImageView.
Creamos una interfaz visual similar a la siguiente:
Seleccionamos el control ImageView y fijarmos la propiedad Visibility con el

valor invisible (esto hace que la imagen no se muestre en pantalla)
Luego inicializamos la propiedad On click del control Button indicando el
nombre del mtodo que se ejecutar al ser presionado:
El cdigo fuente de la clase es:
import
import
import
import
import
android.os.Bundle;
android.view.View;
android.widget.Button;
android.widget.ImageView;

{
Button b1;
ImageView iv1;

created. */
@Override
b1=(Button)findViewById(R.id.button1);
iv1=(ImageView)findViewById(R.id.imageView1);
}
public void ocultarBoton(View v) {
b1.setVisibility(View.INVISIBLE);
iv1.setVisibility(View.VISIBLE);
}
}
Cuando se presiona el botn procedemos a ocultar el botn y hacer visible la
imagen:
public void ocultarBoton(View v) {
b1.setVisibility(View.INVISIBLE);
iv1.setVisibility(View.VISIBLE);
}
Layout (ScrollView y LinearLayout)

El ScrollView junto con un LinearLayout nos permite disponer una cantidad de
componentes visuales que superan la cantidad de espacio del visor del celular
o tablet. Luego el usuario puede desplazar con el dedo la interfaz creada.
Problema:
Disponer un control de tipo ScrollView (que se encuentra en la pestaa

Composite). Como veremos automticamente se crea una componente de tipo
LinearLayout e fijemos la propiedad Orientation del LinearLayout con el valor
vertical:
Luego dispongamos numerosos botones que superen la cantidad de espacio

del dispositivo. Numerar los botones con los nmeros del 1 en adelante:
Luego si ejecutamos el programa veremos que podemos desplazar (scroll) todo

el contenido del visor con el dedo:
Otra posibilidad para la implementacin de una interfaz en Android es disponer

un LinearLayout en la parte superior y un ScrollView en la parte inferior:
Esto hace que en tiempo de ejecucin quede fijo el LinearLayout y podamos

desplazar con el dedo el ScrollView que aparece en la parte inferior:
Icono de la aplicacin
Cuando creamos un proyecto para implementar una aplicacin con el plugin de
Android nos crea un cono por defecto:
Los conos e imgenes se almacenan en la carpeta res (resources) y en esta

hay tres carpetas llamadas:
drawable-mdpi
drawable-ldpi
drawable-hdpi
Y en cada una de estas hay un archivo llamado icon.png:
Como las resoluciones de los dispositivos Android pueden ser muy distintos (un
celular, una tablet, un televisor etc.) se recomienda proporcionar mltiples
copias de cada imagen de recursos a diferentes resoluciones y almacenarlos
en las carpetas nombradas respetando las siguientes reglas:
res/drawable-mdpi/
El cono debe ser de 48*48 pxeles.
res/drawable-ldpi/
75% del tamao de las imgenes almacenadas en la carpeta drawablemdpi
res/drawable-hdpi/
En las versiones ms actuales de Android se propone crear una cuarta carpeta

llamada:
res/drawable-xhdpi/
Problema:
Crear una aplicacin, dibujar y almacenar tres archivos llamados icon.png.
Tener en cuenta que el archivo que se almacena en la carpeta drawable-mdpi
debe ser de 48 pxeles, el de la carpeta drawable-mdpi de 36 pxeles y el de la
carpeta drawable-hdpi debe ser de 72 pxeles de ancho y alto. Ejecutar la
aplicacin y ver el cono nuevo.
Reproduccin de audio (archivo

contenido en la aplicacin)
Veremos los pasos para reproducir un archivo mp3 (otros formatos soportados
por Android son: Ogg, Wav)
Problema:
Disponer dos botones con las etiquetas: Gato y Len, luego cuando se
presione reproducir el archivo de audio respectivo. Los archivos de sonidos
almacenarlos en la misma aplicacin.
Luego de crear el proyecto procedemos a crear una carpeta llamada raw que
dependa de la carpeta res, almacenamos los dos archivos mp3 en dicha
carpeta:
Luego de copiar los archivos a la carpeta debemos refrescar los archivos

contenidos en el proyecto presionando el botn derecho del mouse y
seleccionando la opcin "Refresh":
Podemos comprobar que los dos archivos estn referenciados en el proyecto.

Creamos una interfaz con dos botones e inicializamos las propiedades Text y
On Click de cada botn:
import
import
import
import
android.media.MediaPlayer;
android.os.Bundle;
android.view.View;

{
created. */
@Override
}
public void presionGato(View v) {
MediaPlayer
mp=MediaPlayer.create(this,R.raw.gato);
mp.start();
}
public void presionLeon(View v) {
MediaPlayer mp=MediaPlayer.create(this,
R.raw.leon);
mp.start();
}
}
Cuando copiamos los archivos mp3 se genera luego en la clase R la referencia
a los dos archivos y posteriormente los podemos rescatar cuando creamos un
objeto de la clase MediaPlayer:
MediaPlayer mp=MediaPlayer.create(this,R.raw.gato);
Seguidamente llamamos al mtodo start:

mp.start();
Reproduccin, pausa, continuacin y

detencin de un archivo de audio.
Problema:
Confeccionar una aplicacin que permita Iniciar un archivo mp3, detener,
continuar, detener en forma definitiva y activacin o no de la reproduccin en
forma circular.
Crear un archivo mp3 con el programa Audacity contando del 1 al 30.
Primero creamos un proyecto y definimos los 5 botones y mtodos a ejecutar
cuando se presionen los botones respectivos:
Creamos la carpeta raw y almacenamos en la misma el archivo mp3 creado

previamente. Refrescamos la carpeta raw para actualizar el archivo mp3:
El cdigo fuente es:
import
import
import
import
android.os.Bundle;
android.view.View;
import android.widget.Button;
{
MediaPlayer mp;
Button b1;
int posicion=0;
created. */
@Override
b1=(Button)findViewById(R.id.button5);
}
public void destruir() {
if(mp!=null)
mp.release();
}
public void iniciar(View v) {
destruir();
mp =
MediaPlayer.create(this,R.raw.numeros);
mp.start();
String op=b1.getText().toString();
if (op.equals("No reproducir en forma
circular"))
mp.setLooping(false);
else
mp.setLooping(true);
}
public void pausar(View v) {
if(mp != null && mp.isPlaying()) {

posicion = mp.getCurrentPosition();
mp.pause();
}
}
public void continuar(View v) {
if(mp != null && mp.isPlaying()==false) {
mp.seekTo(posicion);
mp.start();
}
}
public void detener(View v) {
if(mp != null) {
mp.stop();
posicion = 0;
}
}
public void circular(View v) {
detener(null);
if (op.equals("No reproducir en forma
circular"))
b1.setText("reproducir en forma
circular");
else
b1.setText("No reproducir en forma
circular");
}
}
Primero definimos tres atributos uno de la clase MediaPlayer para administrar
el archivo mp3, un entero donde se almacena la posicin actual de
reproduccin en milisegundos (para poder continuarla en el futuro) y la
referencia de un objeto de la clase Button:
MediaPlayer mp;
Button b1;
int
posicion=0;
El mtodo destruir verifica con un if si el objeto de la clase MediaPlayer est

creado procede a liberar recursos del mismo llamando al mtodo release:
public void destruir() {
if(mp!=null)
mp.release();
}
El mtodo iniciar que se ejecuta al presionar el botn "Iniciar" primero llama al

mtodo destruir (para el caso que el mp3 este en ejecucin actualmente)
seguidamente creamos un objeto de la clase MediaPlayer llamando al mtodo
create (en este hacemos referencia al archivo que copiamos a la carpeta raw)
Llamamos al mtodo start. Por ltimo extraemos el texto del quinto botn y
verificamos si la reproduccin debe ejecutarse en forma circular (en forma
indefinida una y otra vez):
public void iniciar(View v) {
destruir();
mp = MediaPlayer.create(this,R.raw.numeros);
mp.start();
if (op.equals("No reproducir en forma circular"))
mp.setLooping(false);
else
mp.setLooping(true);
}
El mtodo pausar verifica que el objeto de la clase MediaPlayer este creado y

en ejecucin, en caso afirmativo recuperamos la posicin actual de
reproduccin y llamamos seguidamente al mtodo pause:
public void pausar(View v) {
if(mp != null && mp.isPlaying()) {
posicion = mp.getCurrentPosition();
mp.pause();
}
}
El mtodo continuar verifica que el objeto de la clase MediaPlayer este creado

y la propiedad isPlaying retorne false para proceder a posicionar en que
milisegundo continuar la reproduccin:
public void continuar(View v) {
if(mp != null && mp.isPlaying()==false) {
mp.seekTo(posicion);
mp.start();
}
}
El mtodo detener interrumpe la ejecucin del mp3 e inicializa el atributo

posicion con cero:
public void detener(View v) {
if(mp != null) {
mp.stop();
posicion = 0;
}
}
Cuando se presiona el botn que cambia si la reproduccin se efecta en

forma circular o no procedemos a extraer su texto y segn dicho valor
almacenamos el valor opuesto:
public void circular(View v) {
detener(null);
if (op.equals("No reproducir en forma circular"))
b1.setText("reproducir en forma circular");
else
b1.setText("No reproducir en forma circular");
}

contenido en una tarjeta SD)
El objetivo de este concepto es acceder a un archivo mp3 almacenado en la
tarjeta SD de nuestro equipo.
Problema:
Disponer un botn con la etiqueta: "Gato", luego cuando se presione reproducir
el archivo de audio respectivo. El archivo de sonido almacenarlo en la tarjeta
SD.
Luego de crear el proyecto debemos ejecutar la aplicacin en modo depuracin
para poder acceder a la tarjeta SD que crea el emulador Android. Para ejecutar
la aplicacin en modo "Debug" presionamos el botn derecha del mouse sobre
el proyecto y seleccionamos la opcin "Debug A" "Android Aplication":
Una vez que se este ejecutando la aplicacin (no importa que todava no
hemos implementado su funcionalidad) procedemos a abrir la ventana "File
Explorer" de Android. Seleccionamos del men de opciones de Eclipse:
Window -> Show View -> Other :
Y en esta ventana seleccionamos Android -> FileExplorer:
Ahora podemos ver la ventana donde administramos los archivos contenidos

en la tarjeta SD que emula el "Android Virtual Device":
En la carpeta sdcard debemos subir el archivo mp3 (debemos seleccionar esta

carpeta
con
el
mouse)
Esto lo hacemos mediante un botn que aparece en la parte derecha de esta
ventana "Push a file onto device", luego de esto tenemos el archivo montado
en la tarjeta SD:
Ahora implementemos la interfaz de nuestra aplicacin (un solo botn) que

cuando se presione llame al mtodo ejecutar:
El cdigo fuente es:
import
import
import
import
import
android.net.Uri;
android.os.Bundle;
android.os.Environment;
android.view.View;

{
created. */
@Override
}
public void ejecutar(View v) {
Uri datos =
Uri.parse(Environment.getExternalStorageDirectory
().getPath() +"/gato.mp3");
datos);
mp.start();
}
}
Creamos un objeto de la clase Uri llamando al mtodo parse donde indicamos
el path y nombre del archivo a recuperar:
Uri
datos
Uri.parse(Environment.getExternalStorageDirectory().getPath()
+"/gato.mp3");
Creamos el objeto de la clase MediaPlayer pasando ahora la referencia del

objeto de la clase Uri:
MediaPlayer mp=MediaPlayer.create(this, datos);
Iniciamos la reproduccin del mp3:

mp.start();
Recordar que para ejecutar este proyecto se debe subir un archivo mp3
llamado "gato.mp3" a la tarjeta SD.

contenido en una tarjeta SD)
El objetivo de este concepto es acceder a un archivo mp3 almacenado en la
tarjeta SD de nuestro equipo.
Problema:
Disponer un botn con la etiqueta: "Gato", luego cuando se presione reproducir
el archivo de audio respectivo. El archivo de sonido almacenarlo en la tarjeta
SD.


carpeta
con
el
mouse)
en la tarjeta SD:
Ahora implementemos la interfaz de nuestra aplicacin (un solo botn) que

cuando se presione llame al mtodo ejecutar:
El cdigo fuente es:
import
import
import
import
android.net.Uri;
android.os.Bundle;
import android.os.Environment;
{
created. */
@Override
}
Uri datos =
Uri.parse(Environment.getExternalStorageDirectory
().getPath() +"/gato.mp3");
datos);
mp.start();
}
}
Creamos un objeto de la clase Uri llamando al mtodo parse donde indicamos
el path y nombre del archivo a recuperar:
Uri
datos
Uri.parse(Environment.getExternalStorageDirectory().getPath()
+"/gato.mp3");
Creamos el objeto de la clase MediaPlayer pasando ahora la referencia del

objeto de la clase Uri:
MediaPlayer mp=MediaPlayer.create(this, datos);
Iniciamos la reproduccin del mp3:

mp.start();
Recordar que para ejecutar este proyecto se debe subir un archivo mp3
llamado "gato.mp3" a la tarjeta SD.
Reproduccin de audio utilizando el

reproductor propio de Android (va
Intent)
Otra forma de ejecutar un archivo mp3 es mediante el reproductor interno de
Android. Esta aplicacin reproduce todos los formatos soportados por Android
y tiene una interfaz que le ser familiar al usuario de nuestra aplicacin.
Problema:
Disponer un botn con la etiqueta: "Ejecutar mp3 con el reproductor propio de
Android", luego cuando se presione reproducir el archivo de audio respectivo
con el reproductor de Android via Intent. El archivo de sonido almacenarlo en la
tarjeta SD.


carpeta
con
el
mouse)
en la tarjeta SD:
Creamos la interfaz con el Button y especificamos el evento On click:
El cdigo fuente es:
import
import
import
import
import
android.net.Uri;
android.os.Bundle;
android.view.View;

{
created. */
@Override
}
Intent intent = new
Intent(android.content.Intent.ACTION_VIEW);
Uri data =
Uri.parse("file:///sdcard"+"/gato.mp3");
intent.setDataAndType(data, "audio/mp3");
startActivity(intent);
}
}
Creamos un objeto de la clase Intent y un objeto de la clase Uri referenciando
al archivo mp3 almacenado en la tarjeta SD. Indicamos mediante el mtodo
setDataAndType el Uri y el tipo de archivo a reproducir. Activamos la aplicacin
mediante startActivity.
Men de opciones con submen

Ahora veremos que podemos desplegar un submen cuando se selecciona una
opcin del men principal.
Problema:
Confeccionar una aplicacin que muestre un men con dos opciones: una que
visualice el texto "Sitios interesantes..." y al ser seleccionado muestre otro
submen con una serie de buscadores. y otra opcin en el men principal para
que finalice el programa.
Creamos el archivo "Android XML File" siguiendo los mismos pasos indicados en
el concepto anterior, procedemos a crear el primer Item y luego creamos el
submen para dicho menuitem como lo indica la siguiente imagen:
Luego aadimos varios Menu Item al Sub-Menu (uno por cada sitio web a
enlazar):
La estructura final del men de opciones debe ser la siguiente:

import android.content.Intent;
import android.net.Uri;
import android.view.Menu;
import android.view.MenuInflater;
import android.view.MenuItem;
@Override
}
@Override
public boolean onCreateOptionsMenu(Menu menu) {
MenuInflater inflater=getMenuInflater();
inflater.inflate(R.menu.menu1, menu);
return true;
}
@Override
public boolean onOptionsItemSelected(MenuItem item) {
Intent i;
switch (item.getItemId()) {
case R.id.item2: i = new Intent("android.intent.action.VIEW",
Uri.parse("http://www.google.com"));
startActivity(i);
break;
Uri.parse("http://www.yahoo.com"));
startActivity(i);
break;
Uri.parse("http://www.bing.com"));
startActivity(i);
break;
case R.id.item5: finish();
}
return true;
}
}
El mtodo onCreateOptionsMenu es idntico al concepto anterior. En el mtodo
onOptionsItemSelected verificamos cual de los MenuItem es seleccionado y
procedemos a invocar mediante un Intent al navegador configurado por defecto
para el dispositivo.
La visualizacin del submen en tiempo de ejecucin es similar a:
31 - Men de opciones con conos en los

MenuItem
Otra posibilidad es disponer grficos dentro de los MenuItem de nuestro

programa.
Problema:
Confeccionar una aplicacin que muestre un men con dos opciones: una que
active el navegador con YouTube y otra que active Facebook. Disponer un
cono para cada MenuItem.
Luego de crear el proyecto procedemos a buscar dos conos representativos
de Youtube y Facebook (dos archivos png de 48 pxeles de ancho y alto) y los
almacenamos en la carpeta drawable-mdpi.
Luego de refrescar la carpeta debemos tener en nuestro proyecto en dicha
carpeta tres archivos:
Procedemos seguidamente a crear el archivo Android XML File (recordemos

que lo hacemos presionando el botn derecho del mouse sobre la carpeta res
y
seleccionando
New
->
Android
XML
File)
Creamos un menu llamado menu1 y seleccionamos el RadioButton Menu.
Ahora tenemos que crear los dos Item y especificar las propiedades Title (con
el texto que queremos que se muestre) y la propiedad Icon.
Para configurar cada icon procedemos a asignar los valores
@drawable/youtube y @drawable/facebook (los nombres coinciden con los
nombres de archivos que copiamos a la carpeta drawable)
Nos queda agregar solo la funcionalidad de cada MenuItem:
import
import
import
import
import
android.net.Uri;
android.os.Bundle;
android.view.Menu;
{
created. */
@Override
}
@Override
public boolean onCreateOptionsMenu(Menu menu)
{
MenuInflater inflater=getMenuInflater();
return true;
}
@Override
public boolean onOptionsItemSelected(MenuItem
item) {
Intent i;
case R.id.item1: i = new
Intent("android.intent.action.VIEW",
Uri.parse("http://www.youtube.com"));
startActivity(i);
break;
case R.id.item2: i = new
Intent("android.intent.action.VIEW",
Uri.parse("http://www.facebook.com"));
startActivity(i);
}
return true;
}
}
Luego cuando lo ejecutamos podemos observar el cono que se muestra en
cada MenuItem:
Men contextuales
Otra variante de men de opciones son los men contextuales que se pueden
asociar a distintos componentes visuales del formulario (TextView, EditText,
ListView
etc.)
Un men contectual aparece cuando el usuario presiona por un tiempo ms o
menos prolongado el control visual.
Problema:
Confeccionar una aplicacin que muestre un EditText y asociarle un men
contextual que permita cambiar el color de fondo del mismo. El men debe
permitir seleccionar entre el rojo, verde y azul.
Primero creamos un proyecto y creamos una interfaz con un control de tipo
EditText:
Luego creamos el archivo XML que contendr el men de opciones

(presionamos el botn derecho del mouse sobre la carpeta res de nuestro
proyecto y seleccionamos New -> Android XML File):
Aparece un dilogo donde debemos indicar el nombre del archivo de recursos

a crear (lo llamamos menu1, este es el nombre del archivo XML que se crear
en una carpeta llamada menu que depende de la carpeta res) y seleccionamos
el RadioButton de menu
Ya tenemos una nueva carpeta llamada menu y un archivo llamado menu1.
Creamos las tres opciones del men:
Ahora veamos como asociar el archivo XML donde definimos el men con el
cdigo Java:
import android.graphics.Color;
import android.view.ContextMenu;
import android.view.ContextMenu.ContextMenuInfo;
import android.widget.EditText;
EditText et1;
@Override
registerForContextMenu(et1);
}
@Override
public void onCreateContextMenu(ContextMenu menu, View v,ContextMenuInfo
menuInfo)
{
menu.setHeaderTitle("Elija el color de fondo:");
MenuInflater inflater = getMenuInflater();
}
@Override
public boolean onContextItemSelected(MenuItem item) {
case R.id.item1:et1.setBackgroundColor(Color.rgb(255, 0, 0)) ;
break;
break;
break;
}
return true;
}
}
En el mtodo onCreateContextMenu asociamos el archivo XML llamando al
mtodo
inflate
de
la
clase
MenuInflate.
Podemos tambin llamar al mtodo setHeaderTitle para mostrar un ttulo en el
men emergente.
@Override
public void onCreateContextMenu(ContextMenu menu, View v,ContextMenuInfo
menuInfo)
{
menu.setHeaderTitle("Elija el color de fondo:");
MenuInflater inflater = getMenuInflater();
}
Para la captura de eventos de los MenuItem debemos implementar el mtodo
onContextItemSelected donde mediante un switch verificamos cual de los
MenuItem fue seleccionado y cambiamos el color de fondo del control EditText:
@Override
public boolean onContextItemSelected(MenuItem item) {
break;
break;
break;
}
return true;
}
AlertDialog simple
El dilogo ms simple que podemos crear con Android en una ventana con un
ttulo, un mensaje y un botn para cerrarlo.
Muy til si tenemos que informar al usuario y no queremos que la ventana
desaparezca hasta que el usuario presione un botn para ocultar el dilogo.
Problema:
Confeccionar una aplicacin que muestre un dilogo cada vez que se inicie la
aplicacin informando que el programa que est ejecutando es un programa de
prueba y no el completo.
Primero
creamos
un
proyecto
llamado:
proyecto031
Lo almacenamos en el paquete: androidya.proyecto031
El cdigo fuente de la aplicacin queda como sigue:
import android.app.AlertDialog;
@Override
AlertDialog.Builder builder = new AlertDialog.Builder(this);
builder.setTitle("Importante");
builder.setMessage("Este es un programa solo de prueba y no la versin

completa");
builder.setPositiveButton("OK",null);
builder.create();
builder.show();
}
}
Como queremos que el dilogo aparezca inmediatamente se arranque la
aplicacin procedemos a incorporar el cdigo en el mtodo onCreate.
Primero debemos importar la clase AlertDialog:
La clase AlertDialog contiene otra clase llamada Builder que es la que encapsula
la creacin de objetos de la clase AlertDialog. Procedemos a definir y crear un
objeto de la clase Builder contenida en la clase AlertDialog:
AlertDialog.Builder builder = new AlertDialog.Builder(this);
Una vez creado el objeto procedemos a llamar al mtodo que define el ttulo a
mostrar en el dilogo:
builder.setTitle("Importante");
El mensaje propiamente dicho lo configuramos llamando al mtodo setMessage:
builder.setMessage("Este es un programa solo de prueba y no la versin
completa");
Mostramos un botn para poder cerrar el dilogo:
builder.setPositiveButton("OK",null);
Finalmente llamamos al mtodo que crea el dilogo y el que lo visualiza:
builder.create();
builder.show();
La interfaz visual del dilogo en tiempo de ejecucin es:
AlertDialog con botones de confirmar

y cancelar
Problema:
Confeccionar una aplicacin que muestre un dilogo cada vez que se inicie la
aplicacin informando: "Acepta la ejecucin de este programa en modo prueba?"
y dos botones para confirmar o rechazar. En caso que se rechace finalizar la
ejecucin del programa.
Primero
creamos
un
proyecto
llamado:
proyecto032
import android.content.DialogInterface;
@Override
AlertDialog.Builder dialogo1 = new AlertDialog.Builder(this);
dialogo1.setTitle("Importante");
dialogo1.setMessage(" Acepta la ejecucin de este programa en modo
prueba ?");
dialogo1.setCancelable(false);
dialogo1.setPositiveButton("Confirmar", new
DialogInterface.OnClickListener() {
public void onClick(DialogInterface dialogo1, int id) {
aceptar();
}
});
dialogo1.setNegativeButton("Cancelar", new
cancelar();
}
});
dialogo1.show();
}
public void aceptar() {
Toast t=Toast.makeText(this,"Bienvenido a probar el programa.",
t.show();
}
public void cancelar() {
finish();
}
}
Creamos un objeto de la clase AlertDialog a travs de la clase Builder:
AlertDialog.Builder dialogo1 = new AlertDialog.Builder(this);

Configuramos el ttulo del dilogo:
dialogo1.setTitle("Importante");
Configuramos el mensaje del dilogo:
dialogo1.setMessage(" Acepta la ejecucin de este programa en modo
prueba ?");
Evitamos que el dilogo sea salteado por cualquier medio distinto a presionar
alguno de los dos botones:
dialogo1.setCancelable(false);
Llamamos al mtodo setPositiveButton indicando el texto a mostrar en el botn y
la clase annima que capturar el evento clic del botn:
dialogo1.setPositiveButton("Confirmar",
new
aceptar();
}
});
De forma similar procedemos con el botn de cancelar:
dialogo1.setNegativeButton("Cancelar",
new
cancelar();
}
});
Mostramos el dilogo:
dialogo1.show();
Definimos los mtodos del Activity que se llamaran desde las clases annimas:
public void aceptar() {
Toast t=Toast.makeText(this,"Bienvenido a probar el programa.",
t.show();
}
public void cancelar() {
finish();
}
La interfaz del dilogo es similar a esta:
Notificaciones o mensajes mediante

la clase Toast
La clase Toast nos permite mostrar un mensaje superpuesto a la ventana por un
perodo de tiempo pero sin congelar la aplicacin. Este mensaje no permite
interactuar con el usuario (no se pueden ingresar datos, seleccionar botones ni
obligar a que se cierre)
Eventualmente se lo puede localizar en distintas partes del dispositivo.
Problema:
Confeccionar una aplicacin que muestre una serie de botones y active mensajes
de notificaciones con la clase Toast.
Primero
creamos
un
proyecto
llamado:
proyecto033
La interfaz visual a implementar son tres botones:
No olvidemos inicializar la propiedad On Click de cada botn con los mtodos:

prueba1, prueba2 y prueba3.
import android.view.Gravity;
import android.view.LayoutInflater;
@Override
}
public void prueba1(View v) {
Toast toast = Toast.makeText(this, "Mensaje 1", Toast.LENGTH_SHORT);
toast.show();
}
toast.setGravity(Gravity.CENTER_VERTICAL, 0, 0);
toast.show();
}
LayoutInflater inflater = getLayoutInflater();
View layout = inflater.inflate(R.layout.toast1, null);
Toast toast = new Toast(getApplicationContext());
toast.setDuration(Toast.LENGTH_LONG);
toast.setView(layout);
toast.show();
}
}
Para el evento click del primer botn mostramos el mensaje con las estructura
ms simple que nos provee la clase Toast. Definimos un objeto de la clase Toast y
llamamos al mtodo makeText pasando como parmetro la referencia del Activity,
el mensaje a mostrar y una constante indicando si queremos que el mensaje
aparezca por un perodo corto o largo de tiempo en la pantalla. Por ltimo
llamamos al mtodo show para que se muestre el mensaje:
toast.show();
}
Si queremos ubicar en otra parte de la pantalla debemos llamar al mtodo

setGravity e indicar en el primer parmetro una constante (en este ejemplo lo
centramos
verticalmente)
En el segundo y tercer parmetro de setGravity podemos desplazarlo una cantidad
de pxeles hacia derecha o izquierda, arriba o abajo segn indiquemos valores
positivos o negativos.
Luego el mtodo completo para este segundo Toast es:
toast.show();
}
Para generar un Toast customizado debemos crear un archivo XML donde

creamos visualmente los controles a mostrar, en este ejemplo creamos el
siguiente archivo (crear un archivo llamado toast1.xml):
Este recurso luego lo incorporamos en el Toast mediante el siguiente cdigo:

LayoutInflater inflater = getLayoutInflater();
View layout = inflater.inflate(R.layout.toast1,null);
Toast toast = new Toast(getApplicationContext());
toast.setDuration(Toast.LENGTH_LONG);
toast.show();
}
Mediante la clase LayoutInflate procedemos a leer el contenido del archivo XML
creado anteriormente y lo enlazamos con el toast mediante el mtodo:
En pantalla luego el Toast customizado aparece de la siguiente forma:
PRACTICA INTEGRADORA
Nombre
Competencias a
desarrollar
Habilidades
Instrucciones para el
alumno
Instrucciones para el
docente
Recursos, materiales
de apoyo
Conocimientos a
adquirir
Competencias
genricas a
desarrollar
Programando mi phone
NO. l
M1 Construye e interpreta modelos matemticos

deterministas o aleatorios mediante la aplicacin de
procedimientos aritmticos, algebraicos, geomtricos y
variacionales, para la comprensin y anlisis de
situaciones reales o formales.
Aplicar las instrucciones necesarias y correctas en el
desarrollo de un programa para dispositivos mviles.
Formar equipos de 5 personas y definir el tema sobre el
cual se desarrollar la aplicacin.
Posteriormente realizar la recopilacin de informacin y
definir requerimientos.
Realizar el diseo de la aplicacin
Realizar cdigo
El docente tomar el rol de Lider del proyecto, revisando
y controlando el avance del mismo.
Empresa, negocio o institucin de donde se obtendr la
informacin.
Computadora,
Dispositivo mvil
Libreta, lpiz
Manera
Aplicar de manera
Realizando el
didctica de
correcta las
ejercicio en el
lograrlas
sentencias
orden indicado.
necesarias para
desarrollar una
aplicacin que
pueda ejecutarse
en cualquier
dispositivo mvil
8.3 Asume una actitud constructiva, congruente con los
conocimientos y habilidades con los que cuenta dentro
de distintos equipos de trabajo.
Errores
Confundir las sentencias de programacin en java y utilizarlas de manera
equivocada.
Contingencias
No contar con los materiales de apoyo, tales como el sistema operativo android, o
con los dispositivos mviles.
Conclusiones de la competencia 1
Durante el desarrollo de esta competencia el alumno adquirir los saberes,
habilidades, atributos y actitudes necesarias sobre los forma de accesar a
Eclipse y desarrollar las aplicaiones de software que puedan ser ejecutadas desde
un dispositivo mvil, tomando en cuenta los requerimientos del usuario.
Para evaluar los atributos, saberes y actitudes de este contenido o competencia se

har uso de los instrumentos de evaluacin como son la LISTA DE COTEJO para
las evidencias de producto, GUIAS DE OBSERVACIN para las evidencias de
desempeo tambin se emplear algunas RUBRICA que
especifiquen la
evaluacin de um producto especifico como son cuadros comparativos.
Competencia 2 Desarrolla aplicaciones para dispositivos mviles sobre

plataformas cerradas.
Saberes
1. Conceptos bsicos
2. Navegando por la red
3. Qu vamos a desarrollar? Un sitio web o una aplicacin?
Ejemplos:
1. Conozco plataformas privadas
Atributos de la Competencia
1.- Conocer una plataforma cerrada
2.- Conocer los dispositivos mviles de plataforma cerrada
Introduccin a la Competencia 2
En la competencia pasada conociste los beneficios de una aplicain abierta, el
sistema operativo Android, aprendiste a utilizar herramientas de desarrollo como
Eclipse + ADT plugin, Android SDK/NDK y un Emulador para programar tu
dispositivo mvil.
Sin embargo la creacin de comunidades de programadores entorno a una
determinada plataforma o sistema operativo, con tutoriales especficos y
herramientas compartidas, est sufriendo una evolucin hacia la creacin
privativa gracias al auge de los smartphones o telfonos inteligentes.
En esta competencia conocers algunos sistemas operativos y herramientas de

desarrollo que se programan bajo una plataforma cerrada, es decir que se
requiere comprar una licencia.
Bienvenidos a esta nueva aventura..
Un recorrido por las plataformas cerradas.
Plataforma cerrada en Windows es un sistema operativo cerrado, esto es por que

su fabricante no entrega el cdigo fuente para que sus usuarios modifiquen el
sistema y sus aplicaciones (Internet Explore, etc.), por ende al ser cerrado posee
otra caractersticas, divide a los usuario por medio de una licencia de uso de
software
(la
clave
que
se
usa
para
instalar
validar
Windows)
Linux es un sistema operativo abierto, por ende su sistema operativo te da la

opcin de entregar el cdigo fuente y el de sus aplicaciones, para que tu lo
adaptes a tus necesidades, y lo compartas con tus amigos, profesores, etc. es por
ello que su software es gratis. Pero como gana dinero? es a travs de los
servicios que se entregan: capacitaciones, cursos, algunas charlas, Libros.
Cada uno de los sistemas operativos ofrece una plataforma para que nosotros
podamos aprovechar y utilizar las mltiples caractersticas de los dispositivos en la
construccin de nuestras aplicaciones:
iOS SDK y Xcode 4

Xcode es el entorno de desarrollo que contiene los diferentes SDKs
para la construccin de aplicaciones para los sistemas de Appel (iOS y
Mac). Se puede descargar de manera gratuita desde la pgina para
desarrolladores
Applehttp://developer.apple.com/xcode/ pero
nicamente las personas que cuenten con Apple ID y estn registradas como
desarrolladores. El SDK de iOS cuenta con un emulador de iOS, pero si se van a
probar aplicaciones directamente en el dispositivo los desarrolladores deben pagar
una cuota anual de US$99 (que tambin incluye la publicacin de aplicaciones a
travs de la Apple Store).
Android SDK y NDK

Las aplicaciones en Android se ejecutan sobre la Dalvik Virtual
Machine (que es una implementacin independiente de una maquina
virtual de Java pero con una arquitectura diferente), pero tambin se
pueden crear aplicaciones que se ejecuten directamente sobre el
sistema operativo (llamadas aplicaciones Nativas).
Las aplicaciones se pueden desarrollar tanto de Java (para la DVM) como en C++
(aplicaciones nativas) a partir de sus respectivas herramientas de desarrollo:
Android SDK para crear aplicaciones con Java

Android NDK para crear aplicaciones con C++
Para la publicacin de aplicaciones, los desarrolladores deben estar registrados en

el Andoird Market y pagar una cuota de registro de US$25.
Symbian SDK
Symbian es la plataforma que ofrece crear aplicaciones de
diferentes sabores. Symbian SDK permite la creacin de
aplicaciones con Qt ySymbian C++ para mviles S60, y
con Java se pueden crear aplicaciones tanto para mviles S60 y
S40.
Las aplicaciones se distribuyen a travs de la Ovi Store con un costo para los
desarrolladores, a la hora de registrarse, de 1.
Windows Phone 7 Developer Tools
Y no faltaba que revisramos como desarrollar para la nueva plataforma de
Microsoft para dispositivos mviles, desarrollo sobre Windows Phone 7
Resumen de costos de publicacin en las diferentes tiendas de aplicaciones
Tienda
Costo
Periodo
Apple Store
US$99
Suscripcin anual
Andoird Market
US$25
Al registrarse
Ovi Store
Al registrarse
Windows Phone
Marketplace
US$99
Gratuito para
estudiantes a travs
deDreamspark
Suscripcin anual
Un ao de
suscripcin gratuita
para estudiantes
(No. 1)
Saberes
TITULO
Navegando por la red
Instrucciones para el alumno: El alumno conocer los sistemas operativos de

desarrollo mvil sobre los cuales podr trabajar. Identificando sus caractersticas,
ventajas y desventajas de cada uno y realizando un ensayo con tal informacin.
Actitudes:
1. Orden.
2. Puntualidad.
3. Responsabilidad.
Saberes a adquirir
Saberes
(No. 2)
Titulo: Qu vamos a desarrollar? Un sitio web o una aplicacin?

Instrucciones para el alumno: El alumno analizar la informacin que a
continuacin se presenta y determinar que es lo que ms le conviene en el
desarrollo de la aplicacin que realiz en la prctica integradora de la competencia
1.
Actitudes:
1. Orden.
2. Responsabilidad
2. Puntualidad.
Saberes a adquirir
A travs de una actitud de orden, tomando en cuenta la
proporcionada y el sustento con acervo bibliogrfico.
investigacin
Qu vamos a desarrollar? Un sitio web o una

aplicacin?
Bsicamente, esto depender de dos grandes factores, infraestructura y costos.
Infraestructura, haciendo referencia a la capacidad que tengamos como empresa(o
programador independiente) y en el medio.
Un ejemplo, sera relativamente sencillo desarrollar un sitio web para telfonos
mviles, con acceso a nuestro sistema, donde, el usuario podra ingresar al sistema
desde cualquier punto, en cualquier momento, usando internet. Pero para ello, sera
necesario que nuestra empresa contara con, para listar algunos, una lnea de
internet dedicada, Ips pblicos, sistemas de seguridad, etc. Los cuales,
indudablemente, involucran el segundo factor, costos.
La segunda alternativa, es la de desarrollar directamente en el dispositivo. Con esta
opcin, la necesidad de infraestructura puede verse reducida, ya que la informacin,
cambios y dems, pueden ser guardados directamente en el dispositivo, para ser
sincronizados luego con el servidor de datos o, como segunda alternativa, al contar

con una red interna, este dispositivo puede trabajar conectado a la misma, teniendo
la posibilidad de realizar transacciones en lnea y usando, la posible infraestructura
ya implementada dentro de la empresa.
Otro punto fuerte de tener un API nativo es poder hacer aplicaciones que muchas
veces no podemos hacerlas va WEB. Como por ejemplo aplicaciones que acceden
a hardware especializado del mvil (GPS, acelermetro, brjula), aplicaciones que
acceden al software especializado del mvil (Media Player, Agenda de contactos,
Email, etc), juegos que necesitan de un API 3D para funcionar, entre otras
aplicaciones.
En resumen, la decisin del qu se va a desarrollar, depender de las necesidades
de cada empresa o individuo e indudablemente, de otros factores adems de los
nombrados, como por ejemplo dependiendo del tipo de aplicacin que buscamos
desarrollar.
Algunas caractersticas (muy importantes de comprender) que comparten los
dispositivos mviles a la hora de la programacin son las siguientes:
La necesidad de ahorrar energa obliga a utilizar procesadores con una

capacidad de cmputo limitada y baja frecuencia de reloj
El uso intensivo de clculos, grficos, sonido, conexiones inalmbricas etc.
limita la vida de la batera
La memoria disponible es muy limitada en comparacin con la de un ordenador

ordinario.
El almacenamiento de datos persistente tambin es muy limitado: memoria interna +
tarjetas SD o similar.
Ejercicio
(No. 1)
Titulo: Conozco plataformas privadas

.
Instrucciones para el alumno: Elabora un mapa mental para cada una de las
plataformas Iphone, Blackberry, Apple, Windows Mobile y otras, que describan el
sistema operativo que utilizan, SDK, modo de venta de las aplicaciones, lenguajes
de programacin, licencia, costo, etc.:
Actitudes:
1. Orden.
2. Puntualidad.
3. Responsabilidad.
Saberes a adquirir: Uso de plataformas cerradas.
o Atributo: Expresa ideas y conceptos mediante representaciones,
lingsticas, matemticas o grficas.

A travs de una actitud de orden, tomando en cuenta las etapas de las estrategias:
con el fin de incluir en ellas los instrumentos necesarios.
Conclusin de la competencia 2
En esta competencia descubriste que el uso de las aplicaciones mviles no solo se
refiere a los telfonos celulares sino a otro tipo de dispositivos, y que los beneficios
o prestaciones que ofrecen se incrementan da a da, por ejemplo:
Acceso a internet y conectividad mediante Bluetooth
Envo de SMS
Acelermetros
Cmaras integradas
Informacin de localizacin de GPS
Sensores de orientacin
Aceleracin 2D y 3D
Conclusin del submdulo
En este submdulo el alumno ha adquirido los conocimientos necesarios para poder

desarrollar aplicaciones mviles tomando en cuenta la gran necesidad que sufren
las empresas, esto les permitir en un futuro no muy lejano poder incorporarse a las
grandes empresas que exigen una gran demanda de programadores, ya que la
programacin de dispositivos mviles y de computadoras es parte medular de la
informtica.
Los conocimientos, ejercicios y prcticas que se han propuesto en esta gua de

aprendizaje te permitieron desarrollar las habilidades, destrezas, conocimientos y
actitudes necesarias para solucionar problemas utilizando la lgica computacional
realizando programas o aplicaciones en una plataforma mvil.
De igual manera, para comprobar lo que has desarrollado de la competencia en
todos los apartados sealados con anterioridad se utilizarn dos tipos de
instrumentos de evaluacin: las guas de observacin para medir tus desempeos
y las listas de cotejo para los productos logrados.
BIBLIOGRAFA
http://en.wikipedia.org/wiki/Maemo
http://talk.maemo.org/showthread.php?p=319423
http://maemo.org/
http://es.wikipedia.org/wiki/Maemo
http://www.htc.com/www/press.aspx
http://en.wikipedia.org/wiki/Android_(operating_system)
http://androidandme.com/category/phones/
http://www.engadget.com/tag/android/

Guia de Aprendizaje de Programacion M3S2

Cargado por

Información del documento

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Guia de Aprendizaje de Programacion M3S2

Cargado por

Copyright:

Formatos disponibles

MODULO III DESARROLLA APLICACIONES WEB Y MOVILES

Finalmente se propondrn desarrollos sencillos de programacin de aplicaciones

Cuando hablamos de desarrollar software para dispositivos mviles, lo primero

El alumno ser capaz de desarrollar aplicaciones mviles sobre plataformas

Conceptos bsicos de programacin orientado a objetos POO Java

2. Conocer los dispositivos mviles de plataforma cerrada

Desarrollo de las Esferas de Competencia

1. Tabla comparativa de sistemas operativos para plataformas libres

Cmo se ofrecen las plataformas libres?

Instrucciones para el alumno: El alumno analizara los tres mtodos o

Escucha, interpreta y emite mensajes pertinentes en distintos contextos

Instrucciones para el alumno|

TABLA DE SENTENCIAS BSICAS

Instrucciones para el alumno: En la siguiente tabla, escribe en cada uno de los

Competencias Genricas: Escucha, interpreta y emite mensajes

Instrucciones para el alumno: Realiza una tabla comparativa de los diferentes

Competencias Genricas: Escucha, interpreta y emite mensajes

Antecedentes de la programacin mvil

Instrucciones para el alumno: El alumno conocer los orgenes de la

En la dcada de los 90, tras la aparicin de estos primeros dispositivos, se

Dispositivo de comunicacin: Un dispositivo de comunicacin es aquel

Adems se incluira el tradicional telfono mvil, precursor indiscutible dentro de

considerablemente las prestaciones del primero mediante pantalla tctil, conexin

Dispositivo de computacin: Los dispositivos de computacin son aquellos

ordenador de sobremesa. Dentro de los dispositivos mviles son sin duda

Smartphone: (cuya traduccin en espaol sera telfono inteligente) es una

grficamente un dispositivo mvil real, con pantalla, teclado y botones de funcin,

En este apartado el profesor explicar la manera de instalar el emulador del

Descarga de herramientas necesarios para programar para Android.

1 - Primero debemos instalar el compilador de Java y la mquina virtual. Estas

Ahora ya podemos cerrar la aplicacin del SDK Manager.exe

En Location disponemos la url: https://dl-ssl.google.com/android/eclipse/

Seleccionamos la carpeta donde descomprimimos SDK de Android y presionamos

En este dilogo asignamos un nombre a nuestro AVD, lo enlazamos con la versin

Ya tenemos todo configurado para el desarrollo de aplicaciones Android.

Conocer la estructura y funcionamiento de Eclipse.

Ya tenemos todo lo necesario instalado para implementar el primer proyecto.

En este dilogo especificamos el nombre del proyecto y el nombre del paquete

No haremos en este momento un anlisis del significado y objetivo de cada

Si seleccionamos la otra pestaa podemos visualizar el archivo main.xml en

El plugin Android ya insert un control de tipo LinealLayout que especifica que

Con esto ya podemos probar nuestra primer aplicacin para un dispositivo

Conociendo ms de Java en Eclipse.

Captura del clic de un botn

Realizar la carga de dos nmeros en controles de tipo EditText. Mostrar un

Veamos paso a paso como creamos la interfaz visual de nuestro programa.

Ahora lo seleccionamos y presionamos el botn derecho del mouse sobre la

Tambin vamos a especificar la propiedad "Id", la misma parece primera en el

Le asignaremos como nombre a este objeto: tv1 (recordemos que se trata de

Presionando el botn derecho sobre el control EditText configuramos la

De la pestaa "Form Widgets" arrastramos un control de tipo "Button":

Inicializamos la propiedad text con el texto "Sumar" y la propiedad id la

Si en este momento ejecutamos la aplicacin aparece la interfaz visual

La clase Proyecto002Activity hereda de la clase Activity. La clase Activity

Como mnimo se debe sobrescribir el mtodo onCreate heredado de la clase

Ahora viene la parte donde definimos variables en java donde almacenamos

public class Proyecto002Activity extends Activity

No definimos TextView para los dos mensajes "Ingrese el primer valor" e

Al mtodo findViewById debemos pasar la constante creada en la clase R

public class Proyecto002Activity extends Activity

public void onCreate(Bundle

Finalmente implementaremos la lgica para sumar los dos valores ingresados

Extraemos el texto de los dos controles de tipo EditText y los almacenamos en

public class Proyecto002Activity extends Activity