Topicos Avanzados de Programacion - Unidad 5 programacion movil

Ingeniería en Sistemas Computacionales
Tópicos Avanzados de Programación
Unidad V: Programación de Dispositivos Móviles
Este material está desarrollado para la asignatura Tópicos Avanzados de Programación, de la carrera de Ingeniería en
Sistemas Computacionales, plan de estudios ISIC-2010-224
TÓPICOS AVANZADOS DE PROGRAMACIÓN

Competencia: Desarrollar aplicaciones básicas para dispositivos móviles.

¿QUÉ ES ANDROID?
• En los últimos años los teléfonos móviles han experimentado
una gran evolución, desde los primeros terminales, grandes y
pesados, pensados solo para hablar por teléfono en cualquier
parte, a los últimos modelos, con los que el término “medio
de comunicación” se queda bastante pequeño. Es así como
nace Android.
• Android es un sistema operativo y una plataforma software,
basado en Linux para teléfonos móviles. Además, también
usan este sistema operativo (aunque no es muy habitual),
tablets, netbooks, reproductores de música e incluso PC’s.

• Android permite programar en un entorno de trabajo
(framework) de Java, aplicaciones sobre una máquina
virtual Dalvik (una variación de la máquina de Java con
compilación en tiempo de ejecución).
• Además, lo que le diferencia de otros sistemas operativos, es
que cualquier persona que sepa programar puede crear nuevas
aplicaciones, widgets1, o incluso, modificar el propio sistema
operativo, dado que Android es de código libre, por lo que
sabiendo programar en lenguaje Java, va a ser muy fácil
comenzar a programar en esta plataforma.

• Android fue desarrollado por Android Inc., empresa que en
2005 fue comprada por Google, aunque no fue hasta 2008
cuando se popularizó, gracias a la unión al proyecto de Open
Handset Alliance, un consorcio formado por 48 empresas de
desarrollo hardware, software y telecomunicaciones, que
decidieron promocionar el software libre.
• Pero ha sido Google quien ha publicado la mayor parte
del código fuente del sistema operativo, gracias al
software Apache, que es una fundación que da soporte
a proyectos software de código abierto.

• Dado que Android está basado en el núcleo de Linux, tiene acceso
a sus recursos, pudiendo gestionarlo, gracias a que se encuentra
en una capa por encima del Kernel, accediendo así a recursos
como los controladores de pantalla, cámara, memoria flash.

TÓPICOSAVANZADOSDEPROGRAMACIÓN
Sistema de Capas
de Android

VERSIONES DISPONIBLES
El sistema operativo Android, al igual que los propios teléfonos móviles,
ha evolucionado rápidamente, acumulando una gran cantidad de
versiones, desde la 1.0 para el QWERTY HTC G1, hasta la 4.0 que acaba
de salir al mercado:
• Cupcake: Android Version 1.5: Características: Widgets, teclado QWERTY
virtual, copy & paste, captura de vídeos y poder subirlos a Youtube
directamente.
• Donut: Android Version 1.6: Características: Añade a la anterior la mejoría
de la interfaz de la cámara, búsqueda por voz, y navegación en Google
Maps.
• Eclair: Android Version 2.0/2.1: Características: Mejoras en Google Maps,
salvapantallas animado, incluye zoom digital para la cámara, y un nuevo
navegador de internet.

• Froyo: Android Version 2.2: Características: Incluye hostpot Wifi,
mejora de la memoria, más veloz, Microsoft Exchange y video-
llamada.
• Ginger Bread: Android Version 2.3: Características: Mejoras del consumo
de batería, el soporte de vídeo online y el teclado virtual, e incluye soporte
para pagos mediante NFC2.
• Honey Comb: Android Version 3.0/3.4: Características: Mejoras para
tablets, soporte Flash y Divx, integra Dolphin, multitarea pudiendo cambiar
de aplicación dejando las demás en espera en una columna, widgets y
homepage personalizable.
• Ice Cream Sandwich: Android Version 4.0: Características: Multiplataforma
(tablets, teléfonos móviles y netbooks), barras de estado, pantalla principal
con soporte para 3D, widgets redimensionables, soporte usb para teclados,
reconocimiento facial y controles para PS3.

ECLIPSE COMO ENTORNO DE TRABAJO
• En este curso de Android, se da por supuesto que el alumno está
familiarizado con el entorno Eclipse y que además tiene nociones básicas
de programación en el lenguaje Java. Lo primero que necesitaremos para
poder programar en Android, es preparar el entorno de trabajo. Es
necesario disponer de una versión de Eclipse Galileo 3.5 o superior para
poder desarrollar nuestros proyectos. Lo segundo que necesitamos es el
kit de desarrollo software para Android o Android SDK, del que se pueden
encontrar varias versiones para diferentes plataformas en la página web:
http://developer.android.com/sdk/index.html

• Si el sistema operativo es
Windows, lo más recomendable,
es descargar el instalador
automático installer_rXX-
windows.exe, y simplemente
seguir las instrucciones.
• Una vez se inicia la instalación, el
instalador comprueba si el equipo
dispone del Java SE Development Kit
(JDK). Si no es así, muestra un mensaje
como el siguiente:

• Simplemente pincha sobre el botón “Visit java.oracle.com” que
redireccionará a la página mencionada para descargar el paquete
necesario. Una vez instalado el JDK, se continúa con la instalación del
SDK. Cuando finalice el instalador, se ejecutará el SDK Manager, en el
que se deberán seleccionar todas las casillas deshabilitadas, para
instalar todas las versiones de Android así como sus herramientas
(Tools).

• Una vez todo esté descargado e instalado, abrir Eclipse para
descargar el ADT Plugin e instalarlo en el entorno de desarrollo.
Se deben seguir los siguientes pasos:
 En la pestaña “Help”, seleccionar “Install New Software”.
 Presionar el botón “Add” en la esquina superior derecha.
 En el cuadro de dialogo que aparece, escribir “ADT Plugin” en el
campo “Name”, y la siguiente URL en el campo “Location” y pulsar
“OK” (Si existe algún problema para enlazar el entorno con éste
link, probar a poner http: eliminando la ‘s’):
https://dl-ssl.google.com/android/eclipse/

• En “Avalaible Software”, seleccionar la casilla correspondiente a
“Developer Tools” y pulsar “Next”.
• Leer y aceptar el Acuerdo de licencia y presionar “Finish”(si salta una
advertencia de seguridad informando de que la autenticidad o validez del
software no se puede establecer, simplemente pulsar “OK”), y reiniciar
Eclipse.
• Lo único que queda es configurar el ADT Plugin. En Eclipse, en la pestaña
“Window”, seleccionar “Preferences”, y elegir “Android” en el panel de la
izquierda. Aparecerá un cuadro de dialogo preguntándo si se quiere enviar
estadísticas a Google, seleccionar la elección y pulsar “Proceed”. Ahora
presionar el botón “Browse” y seleccionar la ruta del directorio dónde se
haya ubicado el SDK (normalmente C:Archivos de
programaAndroidAndroid-sdk) y pulsar “Apply” y “OK”.

• Por último, hay que comprobar
que el SDK está completamente
actualizado. Para ello, en la
pestaña “Window”, seleccionar
“Android SDK and AVD Manager”.
En la sección “Available Packages”,
seleccionar todas aquellas casillas
a instalar. Presionar “Install
Selected” para comenzar con la
descarga e instalación.
• ¡Y ya está! Ya tenemos preparado
el entorno para poder programar
en Android.

PERSPECTIVAS Y EMULADOR
Es la interfaz de usuario (o conjunto de vistas) que provee el JDT Plugin para
poder programar en lenguaje Java. Esta interfaz, proporciona una serie de
herramientas (se puede considerar como una determinada organización de las
vistas), para el correcto desarrollo de programas y aplicaciones, y será la que
utilizaremos para programar en este curso de Android.

PERSPECTIVA DDMS
En este caso, es el ADT Plugin el que nos
proporciona la nueva perspectiva, por lo
que lo primero que hay que hacer es
habilitarla.
En la pestaña “Window”, seleccionar
“Open Perspective” -> “Other”-> “DDMS”.
Esta perspectiva, sirve para poder
programar y realizar debugging al mismo
tiempo, lo que es una forma muy efectiva
de programar.
Aunque se programará con la perspectiva
Java, a la hora de corregir errores se
puede pasar a la perspectiva DDMS.

EMULADOR
• Una vez tengamos el proyecto listo
para ejecutar, entra en escena el
emulador de Android.
• Éste proporciona una vista especial
para comprobar si la aplicación hace
lo que se desea. A continuación se
muestra la vista del emulador para la
versión 2.2 de Android:

• Lo primero que hay que hacer cuando se quiere ejecutar una
aplicación, es pinchar sobre el proyecto con el botón derecho, y
en “Run as” seleccionar “Android Application”, entonces se lanzará
el emulador más apropiado siempre que esté creado (más
adelante, se explicará cómo generar los emuladores).
• No se debe parar la ejecución del emulador, dado que cada vez que se
ejecuta el mismo, necesita de muchos recursos del computador, por lo
que tarda bastante en lanzarse, y realmente no es necesario cerrarlo,
puesto que cada vez que se lleva a cabo una ejecución del proyecto, la
aplicación se reinstala en el emulador.

UN EJEMPLO: “HOLA ANDROID”
• Vamos a crear nuestro primer proyecto en
Android, pero antes veamos de qué se
compone cada uno. Al generar un nuevo
proyecto de Android, dado que estamos
utilizando el entorno Eclipse, éste va a
generar automáticamente la distribución de
carpetas que contendrá la aplicación, la cuál
será común a todos los proyectos Android.

Significado de cada carpeta por separado
• Carpeta src: Recoge la totalidad del código fuente (Java) de la aplicación. En el
ejemplo que vamos a llevar a cabo, Eclipse generará automáticamente el código
base de la ventana principal (Activity).
• Carpeta res: Contiene los recursos necesarios para generar una aplicación Android:
res/drawable/: Guarda las imágenes y se divide en: drawable-ldpi, drawable-
mdpi y drawable-hdpi, que dependerán de la resolución del dispositivo.
res/raw/: Contiene archivos de propósito general, en otro formato que no es
XML.
res/layout/: Incluye los archivos que definen el diseño de la interfaz gráfica,
siempre en XML.
res/values/: Guarda los datos y tipos que utiliza la aplicación, tales como colores,
cadenas de texto, estilos, dimensiones…

 Carpeta gen: Ésta carpeta guarda un conjunto de archivos (de código Java)
creados automáticamente cuando se compila el proyecto, para poder dirigir
los recursos de la aplicación. El archivo R ajusta automáticamente todas las
referencias a archivos y valores de la aplicación (guardados en la carpeta res).
 Carpeta assets: Guarda el resto de archivos necesarios para el correcto
funcionamiento de la aplicación, como los archivos de datos o de
configuración. La principal diferencia entre los recursos que almacena ésta
carpeta y los que guarda la carpeta “res”, es que los recursos de ésta última
generan un identificador por recurso, identificador que se encargará de
gestionar el fichero R y sólo se podrá acceder a ellos a través de
determinados métodos de acceso, mientras que los recursos almacenados en
la carpeta “assets” no generan identificador alguno y se accederá a ellos a
través de su ruta, como se hace con cualquier otro archivo.

 Archivo AndroidManifest.xml: Éste archivo es uno de los más importantes
de cualquier aplicación Android.
 Se genera automáticamente al crear el proyecto, y en él se encuentra
definida la configuración del proyecto en XML (Actividades, Intents, los
permisos de la aplicación, bibliotecas, etc.). Por ejemplo, el proyecto que
vamos a generar (“Hola Android”), contiene un AndroidManifest.xml como el
siguiente:

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="org.example.hello"
android:versionCode="1"
android:versionName="1.0" >
<uses-sdk android:minSdkVersion="8" />
<application
android:icon="@drawable/ic_launcher"
android:label="@string/app_name" >
<activity
android:label="@string/app_name"
android:name=".Hola" >
<intent-filter >
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
</application>
</manifest>

COMPONENTES DE UNA APLICACION
• Android trabaja en Linux, y cada aplicación utiliza un proceso propio.
• Los dispositivos tienen un único foco, la ejecución principal, que es la
aplicación que está visible en la pantalla, pero puede tener varias
aplicaciones en un segundo plano, cada una con su propia pila de tareas. La
pila de tareas es la secuencia de ejecución de procesos en Android.
• Se componen de actividades que se van apilando según son invocadas, y
solo pueden terminarse cuando las tareas que tiene encima están
terminadas, o cuando el sistema las destruye porque necesita memoria,
por lo que tienen que estar preparadas para terminar en cualquier
momento. El sistema siempre eliminará la actividad que lleve más tiempo
parada. En caso de que el sistema necesitase mucha memoria, si la
aplicación no está en el foco, puede ser eliminada por completo a
excepción de su actividad principal.

• Una de las características principales del
diseño en Android es la reutilización de
componentes entre las aplicaciones, es
decir, dos aplicaciones diferentes pueden
utilizar una misma componente, aunque
esté en otra aplicación para así, evitar la
repetición innecesaria de código, y la
consiguiente ocupación de espacio.

ACTIVIDADES
• Una actividad (o Activity) es la componente principal encargada de
mostrar al usuario la interfaz gráfica, es decir, una actividad sería el
equivalente a una ventana, y es el medio de comunicación entre la
aplicación y el usuario. Se define una actividad por cada interfaz del
proyecto.
• Dentro del archivo xml asociado a la actividad, se definen los elementos
tales como ubicación de los elementos en la pantalla (layouts), botones,
textos, checkbox, etc.

• Las actividades tienen un ciclo de vida, es decir, pasan por diferentes
estados desde que se inician hasta que se destruyen. Sus 3 posibles
estados son:
• Activo: ocurre cuando la actividad está en ejecución, es decir, es la tarea
principal.
• Pausado: la actividad se encuentra semi-suspendida, es decir, aun se está
ejecutando y es visible, pero no es la tarea principal. Se debe guardar la
información en este estado para prevenir una posible pérdida de datos
en caso de que el sistema decida prescindir de ella para liberar memoria.
• Parado: la actividad está detenida, no es visible al usuario y el sistema
puede liberar memoria. En caso de necesitarla de nuevo, será reiniciada
desde el principio.

• Una vez definido el ciclo de vida, hay que tener en cuenta qué métodos
son importantes en cada uno de ellos. Aquí están los métodos más
importantes de una actividad:
• OnCreate (Bundle savedInstanceState): es el método que crea la
actividad. Recibe un parámetro de tipo Bundle, que contiene el estado
anterior de la actividad, para preservar la información que hubiera, en
caso de que hubiera sido suspendida, aunque también puede iniciarse
con un null si la información anterior no es necesaria o no existe.
• OnRestart(): reinicia una actividad tras haber sido parada (si continúa
en la pila de tareas). Se inicia desde cero.

• Onstart(): inmediatamente después de onCreate(Bundle
savedInstanceState), o de onRestart() según corresponda. Muestra al
usuario la actividad. Si ésta va a estar en un primer plano, el siguiente
método debe ser onResume(). Si por el contrario se desarrolla por
debajo, el método siguiente será onStop(). Es recomendable llamar al
método onRestoreInstanceState() para asegurar la información.
• OnResume(): establece el inicio de la interactividad entre el usuario y la
aplicación. Solo se ejecuta cuando la actividad está en primer plano. Si
necesita información previa, el método onRestoreInstanceState()
aportará la situación en que estaba la actividad al llamar al onResume().
También puede guardar el estado con onSaveInstanceState().

• OnPause(): se ejecuta cuando una actividad va a dejar de estar en
primer plano, para dar paso a otra. Guarda la información, para poder
restaurar cuando vuelva a estar activa en el método
onSaveInstanceState(). Si la actividad vuelve a primer plano, el siguiente
método será onResume(). En caso contrario, será onStop().
• OnStop(): la actividad pasa a un segundo plano por un largo período.
Como ya se ha dicho, el sistema puede liberar el espacio que ocupa, en
caso de necesidad, o si la actividad lleva parada mucho tiempo.
• OnDestroy(): es el método final de la vida de una actividad. Se llama
cuando ésta ya no es necesaria, o cuando se ha llamado al método
finish().

• La interfaz de usuario es la principal sección de interacción entre persona y
dispositivo. A todas las funcionalidades disponibles se accede a través de la
pantalla, que es por donde se muestra. Es muy importante conseguir que el
manejo sea intuitivo y sencillo, y que el aspecto visual sea atractivo.
• Para construirla, se emplean diferentes objetos que veremos a
continuación, todos ellos descendientes de la clase View.
Fundamentalmente hay 2: los propios objetos de tipo View, como por
ejemplo botones o etiquetas, y que son la base de una subclase llamada
widgets; y los de tipo ViewGroup, que es una clase que extiende a View, y
que son la base de una subclase llamada layouts. La estructura de la
interfaz puede resumirse en el cuadro que se muestra a continuación.

LAYOUTS EN XML
• FRAME LAYOUT: Es el más simple de todos los
existentes. Todos los objetos que se
introduzcan se situarán en la esquina superior
izquierda, por lo que si hay más de uno, se
ocultarán total o parcialmente entre ellos,
salvo que los declaremos como transparentes.
Por este motivo, su uso ideal es el de mostrar
una sola imagen que complete toda la
pantalla.

LINEAR LAYOUT
• Se trata del Layout que viene por
defecto, y uno de los más
sencillos. Los objetos son
estructurados horizontal o
verticalmente, dependiendo del
atributo “orientation” de su
archivo XML correspondiente, y
siempre en una única fila o
columna, con un comportamiento
similar al de una pila. Aquí
podemos ver un código de
ejemplo:

TABLELAYOUT
• Utilizando esta opción, se consigue una
distribución tabular de los elementos de
nuestra interfaz. El comportamiento es
similar al empleado en HTML: se definen
las filas, y dentro de ellas, las columnas. La
tabla tendrá tantas columnas como la fila
con un mayor número de celdas. En cada
casilla, se podrá introducir el objeto
deseado (e incluso dejarla vacía). También
existe la posibilidad de combinar celdas.

RELATIVE LAYOUT
• Es la opción que ofrece más
posibilidades, y por tanto, la más
compleja. Básicamente, empleando este
Layout podremos colocar cada
elemento en el lugar que deseemos,
basándonos en su posición relativa al
padre (contenedor) o a otros elementos
existentes, pudiendo modificar las
distancias entre objetos al antojo del
programador.

OTROS
• Existen, además, otros elementos con comportamiento similar a los
Layouts que hemos visto hasta ahora. Algunos de ellos proporcionan
estructuras invisibles para el usuario (como los aquí descritos hasta
ahora) y otros sí que las muestran. Algunos ejemplos son Gallery,
GridView, Spinner o ViewFlipper.

• MENÚS Y BARRAS DE ACCIONES
• Los menús son la forma más habitual de proporcionar al usuario una serie
de acciones a realizar, ya sea sobre una aplicación o sobre las opciones
del propio dispositivo. Para crearlo, la mejor opción es definirlo en un
archivo XML que irá contenido en el directorio res/menú del proyecto.
Los elementos que lo componen son <menú>, que es el contenedor
principal del resto de elementos; <ítem>, que representa cada una de las
opciones que ofrece el menú, y <group>, que posibilita agrupar los
“ítems” del menú a gusto del usuario, y que puede ser visible o no.
• Hay 3 tipos de menús de aplicación:

• Menú principal: es la colección
primaria de una actividad, que
aparece cuando el usuario acciona el
botón “Menú” del dispositivo.

• Menú contextual: es una “lista” que
surge en la pantalla que aparece cuando
el usuario mantiene presionado un
elemento determinado. Se implementa
como el caso anterior, pero añadiendo un
nuevo elemento de tipo <menu> al
mismo nivel que los elementos <ítem>.

• Submenús: es una lista de opciones que surge cuando el usuario acciona
un elemento del menú, que contiene otro menú anidado.
• Las barras de acciones son barras de título que, además de mostrar algún
tipo de información, pueden ejecutar acciones. El aspecto de ésta es
acorde con el de la aplicación a la que pertenece. Es importante saber
que sólo están disponibles para versiones de Android a partir de la 3.0
(versión 11 del sdk).

DIÁLOGOS Y NOTIFICACIONES
• Los diálogos son avisos o comprobaciones que surgen de una
determinada aplicación, en forma de ventana. La principal diferencia
entre ellos y las notificaciones es que las segundas son meramente
informativas, no se ejecutan en primer plano, y no requieren interacción
directa con el usuario, mientras que los primeros sí se realizan en primer
plano y pueden necesitar esa interacción para llevar a cabo una tarea,
aunque se puede decir que un diálogo es un tipo de notificación.

• AlertDialog: Se recomienda usarlo para mostrar un título, un mensaje de
texto, uno o varios botones, o una lista de elementos para seleccionar.

• ProgressDialog: Su función es indicar que una tarea está siendo llevada a
cabo. Si se conoce el esfuerzo que va a requerir, se mostrará una barra de
progreso que suministre la información sobre lo que se lleva completado y lo
que resta; y si no se conoce, se mostrará un haz que describirá un
movimiento circular.
• Diálogo personalizado: Android da la opción de crear un diálogo con los
elementos/aspecto que el usuario desee. Para ello, es preciso crearse un
layout en XML, guardarlo como “custom_dialog.xml”, y añadirlo como vista al
crear el diálogo. Además, se pueden modificar otros atributos de la misma
manera que hemos visto para otros casos.

Hay 2 tipos de notificaciones:
• Toast Notification: Esta notificación
aparece sobre la ventana en la que
estemos trabajando, y solamente
ocupa el espacio que necesite el
mensaje que muestra. No cierra ni
modifica la actividad que estemos
llevando a cabo, ni acepta interacción
con el usuario, por lo que se
desvanecerá en un periodo corto de
tiempo.

• Status Bar Notification: Esta
notificación añade un mensaje en
la ventana de notificaciones del
sistema, y un icono en la barra de
estado que, al seleccionarlo,
lanzará la aplicación que lo
haactivado. Además, se pueden
configurar de tal modo que al
producirse, el dispositivo suene,
vibre o alerte al usuario de alguna
manera.

Controles básicos.
• En el caso del entorno de desarrollo
de Eclipse, incluye herramientas con
las que se pueden arrastrar y pegar
los componentes en nuestra
aplicación como lo hace un entorno
Visual Studio y otros.

• Control Button: Un control de tipo Button es el botón más básico que
podemos utilizar y normalmente contiene un simple texto. En el ejemplo
siguiente definimos un botón con el texto “Click” asignando su
propiedadandroid:text. Además de esta propiedad podríamos utilizar muchas
otras como el color de fondo (android:background), estilo de fuente
(android:typeface), color de fuente (android:textcolor), tamaño de fuente
(android:textSize), etc.
• Declaración del Button en XML:
<Button
android:id="@+id/button1"
android:layout_width="246dp"
android:layout_height="wrap_content"
android:text="Boton ejemplo" />

Tipos de controles Alfanuméricos
• editText
• textPassword
• textPersonName
• numberPassword
• textEmailAddress
• phone
• textPostalAddress
• textMultiLine
• time
• date
• number
• AutoCompleteTextView

Tipos de controles Gráficos
• TextView
• CheckBox
• Button
• ToggleButton
• RadioButton
• CheckedTextView
• ProgressBar
• SeekBar
• QuickContactBadge
• RadioGroup
• RatingBar
• Switch

Ejemplo de una aplicación sencilla:
• Abrir en Eclipse un nuevo proyecto de Android el cual mostrará una pantalla
básica de diseño
• Mantener el Layout que la aplicación tiene
• Agregar dos botones
• Agregar un cuadro de texto
• Agregar una etiqueta
• Modificar el texto de la etiqueta por medio del archivo xml
• Modificar el texto de los botones por medio del archivo xml
• Crear un evento onClick para uno de los botones, al darle clic debe modificar
texto de etiqueta, así como su color de fondo

Primero: creamos un nuevo
proyecto para Android en la opción:
File-> New -> Android Application
Project

A continuación: Asignamos nombre a nuestro proyecto, en este caso lo
llamaremos ‘Prueba1’

• Aplicación creada con sus carpetas y archivo activity_main.xml

• Aplicación en modo de diseño de pantalla

Agregamos a nuestro
diseño dos botones, un
cuadro de texto y una
etiqueta (TextView)

Abrimos el archivo
activity_main.xml y
revisamos los cambios
que ocurrieron en su
contenido

Modificamos el texto de la
etiqueta y el texto de los
botones por medio del archivo
activity_main.xml

Verificamos el resultado en el
entorno de diseño de pantalla

Creamos el evento onClick
para los botones en el archivo
activity_main.xml

Abrimos el archivo MainActiviti.java ubicado en la carpeta src y creamos
los métodos que controlan los eventos onClick;

Importamos los paquetes para
EditText y TextView
public void onClickBt1 (View v) {
TextView etiqueta = (TextView)findViewById(R.id.TextView1);
etiqueta.setBackgroundColor(Color.RED);
etiqueta.setTextColor(Color.YELLOW);
}
public void onClickBt2 (View v) {
EditText texto = (EditText)findViewById(R.id.texto);
TextView etiqueta = (TextView)findViewById(R.id.Etiqueta);
etiqueta.setText(texto.getText().toString());
}
import android.os.Bundle;
import android.app.Activity;
import android.view.Menu;
import android.view.View;
import android.graphics.Color;
import android.widget.EditText;
import android.widget.TextView;
Creamos los dos métodos para
los eventos onClick

Finalmente ejecutamos
nuestra aplicación

Ejercicio
Hacer una aplicación en Android que capture:
• Primer Nombre
• Segundo Nombre
• Primer Apellido
• Segundo Apellido
• Fecha de Nacimiento
• Sueldo mensual
El programa debe procesar el nombre y la fecha de nacimiento y crear un RFC al
menos con Prefijo y Numeración. Además, dependiendo del salario que tenga la
persona indicar porcentaje de impuestos que se paga mensual de acuerdo a la
tabla del SAT.

Topicos Avanzados de Programacion - Unidad 5 programacion movil

Más contenido relacionado

La actualidad más candente (20)

Destacado (20)

Similar a Topicos Avanzados de Programacion - Unidad 5 programacion movil (20)

Más de José Antonio Sandoval Acosta (20)

Último (20)

Topicos Avanzados de Programacion - Unidad 5 programacion movil