IMPLEMENTANDO

 FUNCIONALIDADES  -­‐  ACTIVITY  

 
Una  Activity  es  un  componente  de  la  aplicación  que  implementa  las  funcionalidades  asociadas  a  
una  interfaz  o  una  pantalla  con  la  que  los  usuarios  interactúan.  Por  tanto,  así  como  una  aplicación  
puede  tener  múltiples  pantallas,  así  mismo  tendrá  múltiples  actividades.  
 
Para  poder  usar  las  actividades  en  una  aplicación  se  debe  registrar  información  sobre  ellas  en  el  
manifiesto  de  la  aplicación  y  se  debe  administrar  su  ciclo  de  vida  de  manera  apropiada.    
 
MANIFIESTO  DE  LA  APLICACIÓN  
 
Todas   las   aplicaciones   deben   tener   un   archivo   [Link]   en   la   carpeta   manifest   del  
directorio  raíz.  El  archivo  de  manifiesto  proporciona  información  esencial  sobre  la  aplicación  al  
sistema  Android,  información  que  el  sistema  debe  tener  para  poder  ejecutar  el  código  de  la  app.  
 
Entre  otras  cosas,  el  archivo  de  manifiesto  hace  lo  siguiente:  
 
•   Nombra   el   paquete   de   Java   para   la   aplicación.   El   nombre   del   paquete   sirve   como   un  
identificador  único  para  la  aplicación.  
•   Describe   los   componentes   de   la   aplicación,   como   las   actividades.   También   nombra   las  
clases  que  implementa  cada  uno  de  los  componentes  y  publica  sus  capacidades,  como  los  
mensajes   Intent   con   los   que   pueden   funcionar   (lo   explicaremos   más   adelante).   Estas  
declaraciones   notifican   al   sistema   Android   los   componentes   y   las   condiciones   para   el  
lanzamiento.  
•   Declara  los  permisos  debe  tener  la  aplicación  para  acceder  a  las  partes  protegidas  de  una  
API   e   interactuar   con   otras   aplicaciones.   También   declara   los   permisos   que   otros   deben  
tener  para  interactuar  con  los  componentes  de  la  aplicación.  
•   Declara  el  nivel  mínimo  de  Android  API  que  requiere  la  aplicación.  
•   Enumera  las  bibliotecas  con  las  que  debe  estar  vinculada  la  aplicación.  
 
Veamos  el  archivo  manifest  para  la  app  sencilla  de  Hola  Mundo.  
 
  
 
En  este  archivo  podemos  ver  los  siguiente:  
 
•   El  nombre  del  paquete  que  contiene  la  aplicación:  package  
•   Dentro   de   <application>   se   definen   aspectos   propios   de   la   aplicación,   como   el   icono:  
android:icon,  el  nombre  de  la  app:  android:label,  el  tema:  android:theme.  
•   Se   describe   la   única   actividad   que   tiene   la   aplicación:   <activity   android:name   =  
".MainActivity">  
•   Dentro   de   la   actividad   se   definen   los   filtros   de   intenciones:   <intent-­‐filter>   que  
explicaremos  a  continuación.  
 
INTENCIONES  
 
Una  Intención  o  Intent  es  un  objeto  que  se  usa  para  solicitar  una  acción  de  otro  componente  de  
la  aplicación.  Existen  tres  ocasiones  en  las  que  normalmente  se  usan:  
 
•   Para   comenzar   una   actividad:     Se   puede   iniciar   una   nueva   instancia   de   una   Activity  
pasando   una   Intent   a   startActivity().   La   Intent   describe   la   actividad   que   se   debe   iniciar   y  
contiene  los  datos  necesarios  para  ello.  
 
•   Para  iniciar  un  servicio:  Un  Service  es  un  componente  que  realiza  operaciones  en  segundo  
plano  sin  una  interfaz  de  usuario.  Puede  iniciar  un  servicio  para  realizar  una  operación  
única  (como  descargar  un  archivo)  pasando  una  Intent  a  startService().  La  Intent  describe  
el  servicio  que  se  debe  iniciar  y  contiene  los  datos  necesarios  para  ello.  
 
•   Para  entregar  un  mensaje:  Un  mensaje  es  un  aviso  que  cualquier  aplicación  puede  recibir.  
El   sistema   entrega   varios   mensajes   de   eventos   del   sistema,   como   cuando   el   sistema  
arranca  o  el  dispositivo  comienza  a  cargarse.  Se  puede  enviar  un  mensaje  a  otras  apps  
pasando  una  Intent  a  sendBroadcast(),  sendOrderedBroadcast()  o  sendStickyBroadcast().  
Por  tanto,  una  intención  representa  la  voluntad  de  realizar  alguna  acción  o  tarea,  como  realizar  
una  llamada  de  teléfono  o  visualizar  una  página  web.  Una  intención  permite  lanzar  una  actividad  
o  servicio  de  nuestra  aplicación  o  de  una  aplicación  diferente.    
 
Existen  dos  tipos  de  intenciones:  
 
•   Intenciones  explícitas:  en  este  tipo  de  intenciones  se  indica  exactamente  el  componente  
a   lanzar.   Su   utilización   típica   es   la   de   ir   ejecutando   los   diferentes   componentes   internos  
de  una  aplicación.  Por  ejemplo,  desde  la  actividad  principal  lanzar  otra  actividad.  
•   Intenciones  implícitas:    en  este  tipo  de  intenciones  se  pueden  solicitar  tareas  abstractas,  
como   “tomar   una   foto”   o   “enviar   un   mensaje”.   Además,   las   intenciones   se   resuelven   en  
tiempo   de   ejecución,   de   forma   que   el   sistema   mirará   cuantos   componentes   han  
registrado  la  posibilidad  de  ejecutar  ese  tipo  de  intención.  Si  encuentra  varias  el  sistema  
puede  preguntar  al  usuario  el  componente  que  prefiere  utilizar.  
 
FILTROS  DE  INTENCION    
 
Los  filtros  de  intención  son  una  característica  muy  poderosa  de  la  plataforma  Android.  Brindan  
la  capacidad  de  iniciar  una  actividad  basada  no  solo  en  una  solicitud  explícita,  sino  también  en  
una  implícita.  Por  ejemplo,  una  solicitud  explícita  podría  decirle  al  sistema  "Iniciar  la  actividad  
Enviar  correo  electrónico  en  la  aplicación  Gmail".  Por  el  contrario,  una  solicitud  implícita  le  dice  
al  sistema  "Iniciar  una  pantalla  Enviar  correo  electrónico  en  cualquier  actividad  que  pueda  hacer  
el  trabajo".  Cuando  la  interfaz  de  usuario  del  sistema  le  pregunta  al  usuario  qué  aplicación  usar  
en  la  realización  de  una  tarea,  ese  es  un  filtro  de  intención  en  el  trabajo.  
 
Esta   característica   se   puede   usar   declarando   un   atributo   <intent-­‐filter>   en   el   elemento  
<activity>.  La  definición  de  este  elemento  incluye  un  elemento  <action>  y,  opcionalmente,  un  
elemento  <category>  y  /  o  un  elemento  <data>  .  Estos  elementos  se  combinan  para  especificar  
el  tipo  de  intención  a  la  que  la  actividad  puede  responder.    
 
¿Que  significan  y  que  opciones  existen  en  los  elementos  <action>  y  <category>?  
 
 
CICLO  DE  VIDA  DE  LAS  ACTIVIDADES  
 
Normalmente,   cuando   un   usuario   inicia   la   aplicación   por   primera   vez   se   lanza   una   actividad  
principal,  la   cual  a  su   vez  puede   iniciar  otra   actividad  para  poder  realizar  diferentes  acciones.  
Cada  vez  que  se  inicia  una  actividad  nueva,  se  detiene  la  actividad  anterior  y  se  coloca  en  una  
pila.  Cuando  se  inicia  una  actividad  nueva,  se  la  incluye  en  la  pila  de  actividades  y  se  muestra  al  
usuario.  La  pila  de  actividades  es  una  pila  LIFO  (la  última  en  entrar  es  la  primera  en  salir),  por  lo  
que,  cuando  el  usuario  termina  de  interactuar  con  la  actividad  actual  y  presiona  el  botón  Atrás,  
se  quita  de  la  pila  (y  se  destruye)  y  se  reanuda  la  actividad  anterior.    
 
Cada  actividad  maneja  métodos  de  callback  que  permiten  manejar  su  ciclo  de  vida.  Cada  cambio  
de   estado   de   la   actividad   activa   un   método   de   callback   (creación,   detención,   reanudación   o  
destrucción)   el   cual   permite   realizar   una   tarea   específica   al   cambio   de   estado.   Por   ejemplo,  
cuando   se   detiene   una   actividad,   esta   debería   liberar   la   conexión   de   red   o   la   base   de   datos.  
Cuando  se  reanuda  la  actividad,  se  puede  volver  a  adquirir  los  recursos  necesarios  y  reanudar  las  
acciones  que  se  interrumpieron.  Todas  estas  transiciones  de  estado  forman  parte  del  ciclo  de  
vida  de  la  actividad.  
 
A   continuación,   se   detallan   los   diferentes   callback   que   forman   parte   del   ciclo   de   vida   de   la  
actividad:  
 
onCreate():    Este  callback  se  activa  cuando  el  sistema  crea  la  actividad.  Su  implementación  debe  
inicializar  los  componentes  esenciales,  por  ejemplo,  crear  vistas  y  asociar  parámetros.  Lo  más  
importante  es  que  siempre  debe  llamar  a  setContentView()  para  definir  la  interfaz  de  usuario  
asociada   a   la   actividad.   Después   de   finalizar   onCreate()   siempre   se   debe   llamar   al   callback  
onStart().  
 
onStart():  Cuando  onCreate()  termina,  la  actividad  entra  en  el  estado  Iniciado  y  se  vuelve  visible  
para  el  usuario.  Este  callback  contiene  los  preparativos  finales  de  la  actividad  para  pasar  al  primer  
plano  y  poder  interactuar  con  el  usuario.  
 
onResume  ():  El  sistema  invoca  callback  justo  antes  de  que  la  actividad  comience  a  interactuar  
con   el   usuario.   En   este   punto,   la   actividad   se   encuentra   en   la   parte   superior   de   la   pila   de  
actividades  y  captura  todas  las  entradas  del  usuario.  La  mayor  parte  de  la  funcionalidad  principal  
de  una  aplicación  se  implementa  en  el  método  onResume().  Después  de  este  callback  siempre  
seguirá  onPause().  
 
onPause():    El  sistema  llama  a    onPause()  cuando  la  actividad  pierde  el  foco  y  entra  en  un  estado  
Pausado.   Este   estado   ocurre   cuando,   por   ejemplo,   el   usuario   toca   el   botón   Atrás.   Cuando   el  
sistema   solicita   onPause()   significa   que   su   actividad   todavía   es   parcialmente   visible,   pero   a  
menudo   es   una   indicación   de   que   el   usuario   abandonará   la   actividad   esta   pasará   al   estado  
Detenido  o  Reanudado.  
 
Una  actividad  en  este  estado  puede  continuar  actualizando  la  interfaz  si  esto  es  lo  que  se  espera.  
Ejemplo   de   esto   es   una   pantalla   que   muestra   un   mapa   de   navegación   o   un   reproductor  
multimedia.  Incluso  si  tales  actividades  pierden  el  foco,  el  usuario  espera  que  la  interfaz  continúe  
actualizándose.  
 
Una   vez   que   onPause()   termina   de   ejecutarse,   el   siguiente   callback   puede   ser   onStop()   o  
onResume().  
 
onStop():   El   sistema   llama   onStop()   cuando   la   actividad   ya   no   es   visible   para   el   usuario.   Esto  
puede   suceder   porque   la   actividad   está   siendo   destruida,   porque   una   nueva   actividad   está  
comenzando,  o  porque  una  actividad  existente  está  entrando  en  un  estado  Reanudado  y  está  
cubriendo  la  actividad  detenida.  En  todos  estos  casos,  la  actividad  detenida  ya  no  es  visible.  
 
El  siguiente  callback  al  que  llama  el  sistema  es  onRestart(),  si  la  actividad  vuelve  a  interactuar  con  
el  usuario,  o  onDestroy()  si  la  actividad  finaliza  por  completo.  
 
onRestart   ():   El   sistema   invoca   este   callback   cuando   una   actividad   en   el   estado   Detenido   está   a  
punto   de   reiniciarse.   onRestart()   restablece   el   estado   de   la   actividad   desde   el   momento   en   que  
se  detuvo.  Este  callback  siempre  es  seguido  por  onStart().  
 
OnDestroy  ():  El  sistema  invoca  este  callback  antes  de  que  se  destruya  una  actividad.  Este  callback  
es  el  último  que  recibe  la  actividad.  onDestroy()  generalmente  se  implementa  para  garantizar  
que   se   liberen   todos   los   recursos   de   una   actividad   cuando   se   destruye   la   actividad   o   el   proceso  
que  la  contiene.  
 
La  siguiente  gráfica  tomada  de   [Link]
419  muestra  todo  este  proceso:  
 
  
 
 
 
RECURSOS  Y  ARCHIVO  [Link]  
 
Un   recurso   es   un   archivo   que   presenta   algo   que   puede   ser   dibujado   en   pantalla,   un   formato   de  
archivo  para  sus  clases  o  un  valor  que  puede  ser  asociado  en  una  aplicación,  tal  como  un  string  o  
valor  hexadecimal  para  un  color.  Los  recursos  de  la  aplicación  se  encuentran  en  el  directorio  res,  
como  lo  vimos  en  la  actividad  anterior.  
 
Cuando  se  compila  la  aplicación  automáticamente  se  genera  la  clase  R,  que  contiene  el  ID  de  
recurso  de  todos  los  recursos  del  directorio  res/.  Para  cada  tipo  de  recurso  hay  una  subclase  R  
(por  ejemplo,  [Link]  para  todos  los  recursos  de  elementos  de  diseño),  y  para  cada  recurso  
de  ese  tipo  hay  un  valor  entero  estático  (por  ejemplo,  [Link]).  Ese  valor  entero  es  el  ID  
del  recurso  que  se  puede  usar  para  recuperar  el  recurso.  
 
El  ID  de  recurso  siempre  está  compuesto  por:  
 
•   El  tipo  de  recurso:  Cada  recurso  se  agrupa  en  un  “tipo”,  como  string,  drawable  y  layout.    
•   El   nombre   del   recurso:   que   es   el   nombre   de   archivo   sin   la   extensión   o   el   valor   en   el  
atributo  XML  android:name,  si  el  recurso  es  un  valor  simple  (como  una  string).  
 
Existen  dos  maneras  de  acceder  a  un  recurso:  
 
•   En   código:   Usando   un   valor   entero   de   una   subclase   de   la   clase   R;   por   ejemplo:  
[Link].  string  es  el  tipo  de  recurso  y  hello  es  el  nombre  del  recurso.    
•   En  XML:  Usando  una  sintaxis  XML  que  también  corresponde  al  ID  de  recurso  definido  en  
tu   clase   R;   por   ejemplo:   @string/hello.   string   es   el   tipo   de   recurso   y   hello   es   el   nombre  
del  recurso.    
 
¿Cuáles  son  los  recursos  que  por  defecto  aparecen  en  todo  proyecto  en  Android  Studio  y  cuál  es  
su  significado?  
 
 
LA  PRIMERA  ACTIVITY  
 
Las   actividades   en   Android   se   definen   como   archivos   java   independientes   y   se   guardan   en   la  
carpeta  java.  Cuando  se  crea  un  proyecto,  con  los  valores  por  defecto,  se  crea  un  archivo  para  la  
actividad  principal  denominado  [Link].  
 
  
 
Lo  primero  que  encontramos  en  este  archivo  es  la  definición  de  una  nueva  clase  MainActivity  
que   extiende   en   este   caso   de   un   tipo   especial   de   Activity   llamado   AppCompatActivity,   que  
soporta  entre  otras  cosas  la  utilización  de  la  ActionBar  en  las  aplicaciones  (ActionBar  es  la  barra  
de  título  y  menú  superior  que  se  utiliza  en  la  mayoría  de  aplicaciones  Android).    
 
Dentro  de  la  clase  se  hace  un  llamado  al  método  onCreate(),  que  inicia  el  ciclo  de  vida  de  esa  
actividad.  También  se  hace  el  llamado  al  método  setContentView([Link].activity_main).  Con  
esta   llamada   se   le   indica   a   Android   que   debe   establecer   como   interfaz   gráfica   de   esta   actividad  
la   definida   en   el   recurso   [Link].activity_main,   que   es   la   que   se   especificó   en   el   archivo  
/src/main/res/layout/activity_main.xml  (que  trabajamos  en  la  actividad  anterior).  
 
Para   entender   algunos   de   los   conceptos   que   hemos   visto   desarrollaremos   una   aplicación   de  
Login,  en  la  cual  pediremos  un  nombre  y  cuando  el  usuario  lo  escriba  y  le  dé  clic  en  el  botón  de  
enviar   pasaremos   a   otra   pantalla   donde   daremos   un   saludo   con   el   nombre   ingresado   por   el  
usuario.  
 
Todo  el  proceso  lo  veremos  en  el  siguiente  paso  a  paso:  
 
1.   Creamos  un  nuevo  proyecto  llamado  Login  
 

     
  

     
 
2.   Creamos  la  segunda  actividad.  Le  daremos  el  nombre  SaludoActivity  
 

 
 
    
 
Podemos   ver,   que   automáticamente   se   crea   el   layout   correspondiente   de   nombre  
activity_saludo.xml.  
 
3.   En   los   archivos   correspondientes   a   los   layouts   implementamos   las   interfaces   que  
necesitamos.  En  activity_main  implementaremos  un  LinearLayout,  allí  colocaremos  un  
TextView,  un  EditText  y  un  Button,  para  que  el  usuario  ingrese  el  nombre.  
 

 
 
En  activity_saludo.xml,  también  implementaremos  un  LinearLayout  con  un  TextView  donde  se  
mostrará  el  mensaje  de  saludo  con  el  nombre  ingresado.  
 
Es   importante   aquí   tener   en   cuenta   los   identificadores   que   se   les   colocaron   a   los   diferentes  
recursos.  text1  al  TextView,  nombre  al  EditText  y  boton  al  Button.  
 
  
 
El  identificador  del  TextView  en  esta  interfaz  es  saludo.  
 
4.   Ahora  debemos  implementar  el  código  que  permitirá  acceder  a  lo  que  el  usuario  escriba  
y  detectar  cuando  de  clic  en  el  botón  y  ejecute  la  acción  correspondiente,  que  consiste  
en  enviar  el  dato  a  la  siguiente  actividad  y  lanzarla.  Y  en  la  siguiente  actividad  recuperar  
dicha  información  y  mostrarla.  Para  esto,  debemos  hacer  lo  siguiente:  
 
a.   En   la   activity   principal   MainActivity,   en   el   método   OnCreate,   obtener   una  
referencia   a   los   recursos   de   la   interfaz,   en   este   caso   el   EditText   y   el   Button.   Para  
ello  creamos  unas  variables  del  tipo  adecuado  y  las  relacionamos  con  los  recursos,  
a  través  del  identificador  de  los  mismos  y  su  acceso  por  medio  de  la  clase  R  con  la  
función  findViewById  
 

 
 b.   Implementamos   un   Listener   (escuchador   de   eventos)   para   realizar   una   acción  
cuando  el  usuario  haga  clic  en  el  botón.  En  este  punto  a  través  de  una  intención  le  
pasamos  el  dato  que  escribe  el  usuario  y  lanzamos  la  siguiente  actividad.  
 

 
 
c.   En   la   siguiente   actividad   SaludoActivity   obtenemos   la   referencia   al   recurso  
TextView  de  la  interfaz,  igual  que  lo  hicimos  en  el  punto  anterior.  
 

 
 
 d.   Recogemos  a  través  de  la  intención  los  datos  que  le  fueron  enviados.  
 

 
 
NOTA:  A  medida  que  se  vaya  escribiendo  el  código  se  deben  ir  insertando  los  include  necesarios.  
Android  Studio  lo  hace  de  manera  automática  cuando  se  presionan  las  teclas  ALT  y  ENTER.  
 
5.   Por  último,  ejecutamos  el  proyecto.  
 

     
 
CONTINUANDO  CON  EL  EJEMPLO  AppExample  
 
Siguiendo  con  el  ejemplo  de  la  actividad  anterior  de  nuestro  módulo  (  AppExample),  miremos  las  
actividades  asociadas.  
 
Hasta  el  momento  llevamos  solo  una  actividad  ScrollingActivity,  veamos  que  contiene:  
 

 
 
Dentro  del  método  onCreate  se  tiene  lo  siguiente:  
 
•   La   asociación   de   la   actividad   con   el   layout   correspondiente   a   través   de   la   función  
setContentView.  
•   Referencias  a  los  recursos  que  vienen  con  la  plantilla  que  se  seleccionó,  en  este  caso  la  
plantilla  viene  con  dos  recursos:  
o   El   toolbar   que   es   la   barra   que   aparece   al   principio   de   la   interfaz   donde   se  
colocarían  las  opciones  del  menú  (si  este  existe).  
o   El  botón  flotante  (FloatingActionButton)  y  a  su  vez  el  listener  para  implementar  
las  acciones  adecuadas  cuando  se  dé  clic  en  él.  
 
Se  tienen  además  dos  métodos  adicionales  para  la  creación  de  un  menú  y  la  actuación  ante  la  
selección  de  cada  uno  de  sus  ítems  (en  caso  de  que  se  requiera)  
 
Para  continuar  con  el  desarrollo  de  esta  aplicación,  crearemos  las  actividades  correspondientes  
a  cada  uno  de  las  opciones  que  se  presentan.  
 
Empecemos  por  la  opción  INGRESO  DE  DATOS.  Veamos  el  proceso  paso  a  paso.  
 
1.   Lo  primero  que  debemos  hacer  es  crear  una  activity  que  estará  asociada  a  la  interfaz  que  
se  debe  presentar  cuando  el  usuario  seleccione  la  opción  de  INGRESO  DE  DATOS.  
 

 
 
Le  damos  el  nombre  FormActivity  y  automáticamente  también  se  creará  el  layout  activity_form.  
 

 
 
 2.   En   activity_form   copiamos   lo   que   en   la   actividad   anterior   habíamos   creado   como  
[Link].    
 

 
 
 
3.   En  la  actividad  principal  ScrollingActivity  creamos  una  referencia  al  botón  asociado  a  la  
opción   INGRESO   DE   DATOS.   Recuerden   que   a   ese   botón   le   pusimos   el   identificador  
button01  en  el  layout  correspondiente  (content_scrolling.xml).  
 
  
 
4.   Después   debemos   crear   el   listener   para   detectar   cuando   el   usuario   seleccione   la   opción  
INGRESO   DE   DATOS   y   desde   allí   llamar   a   la   actividad   que   creamos   anteriormente  
FormActivity.  Para  ello  creamos  una  intención  Intent  para  poder  iniciar  la  actividad.  
 

 
 
5.   Probemos   que   funciona   la   primera   opción.   Ejecutamos   el   proyecto   y   damos   clic   en   la  
opción  INGRESO  DE  DATOS.  
 

     
 6.   ¿Que  deberíamos  hacer  para  implementar  la  segunda  opción  de  nuestro  menú  (ACERCA  
DE)?  
 
ACCESO  A  BASES  DE  DATOS  DESDE  ANDROID  
 
Ya  que  casi  todas  las  aplicaciones  que  ustedes  han  propuesto  para  ser  desarrollada  en  el  módulo  
2  de  nuestro  curso  requieren  del  acceso  a  una  base  de  datos,  les  dejo  unos  videos  donde  explico  
todo  el  proceso  de  desarrollo  de  una  aplicación  sencilla  en  la  que  a  través  de  un  formulario  se  
recogen   datos   para   ser   almacenados   en   una   base   de   datos   o   para   realizar   una   consulta   a   la  
misma.  
 

 
android-­‐mysql-­‐[Link]  
android-­‐mysql-­‐[Link]