¿Qué es activity?

Componente fundamental en el desarrollo de Android, representa una pantalla, en la cual el

usuario puede interactuar con la aplicación, es la parte de la programación se refleja como una
instancia de la clase activity….. entonces un activity es una clase ya cada pantalla es una
instancia de la clase activity.

Un layout representa una pantalla..cada activity esta conectado con un layout que es un archivo
xml y es la plantilla que nos da el molde de la apariencia de esa pantalla

Una Activity en Android se corresponde con una pantalla de nuestra App.

En realidad, es un punto de entrada que Android puede cargar en cualquier momento. Se

compone de:

 Una clase, que normalmente extiende de AppCompatActivity. Es donde definimos el

código de lo que queremos que haga la App.
 Un layout, que identifica la apariencia de la vista, el diseño. Tiene formato XML, pero se
puede utilizar el diseñador para hacerlo más sencillo

Una definición de su uso, que se realiza en el AndroidManifest.

El método setContentView() es un método importante en la clase Activity de Android y se utiliza
para establecer el diseño de la interfaz de usuario de una actividad. Su función principal es inflar
(es decir, cargar y crear) el diseño definido en un archivo XML y establecerlo como el contenido
visual de la actividad.

El método setContentView() se llama típicamente en el método onCreate() de la actividad, que se

ejecuta cuando la actividad está siendo creada. Al llamar a setContentView(), se proporciona como
argumento la referencia al archivo de diseño XML que describe la interfaz de usuario deseada para
esa actividad.

En Android, los archivos de diseño se crean y se almacenan en la carpeta res/layout. Esta carpeta
se encuentra dentro del directorio de recursos (res) en la estructura de directorios del proyecto de
Android.

Cuando se crea un nuevo proyecto en Android Studio, se crea automáticamente una carpeta
llamada res que contiene subcarpetas para diferentes tipos de recursos, como diseños, imágenes,
valores de strings, estilos, etc. El directorio res/layout es donde se deben colocar los archivos XML
que definen los diseños de la interfaz de usuario.

*Si creas un proyecto sin activity no se crea la carpeta layout entonces hay que crearla endentro
de la carpeta res. (New Android resource directory y en type escoger layout)

*Una vez creada la carpeta de layout se crea un new Resource file y se nombran escribiendo la
palabra activity_nombre (al contrario de las clases ya que en las clases es el nombre con
mayúscula en cada palabra ejemplo MyFirstActivity)

Dentro de la carpeta res/layout, puedes crear subcarpetas adicionales para organizar tus archivos
de diseño si así lo deseas. Por ejemplo, puedes crear una subcarpeta llamada
res/layout/actividades para agrupar los diseños de las actividades de tu aplicación.

En resumen, los archivos de diseño en Android se crean en la carpeta res/layout, y esta carpeta
proporciona la ubicación para almacenar los archivos XML que describen la apariencia y estructura
de la interfaz de usuario de tu aplicación.
Actividades
Por definición, una actividad es un componente que nos provee de una pantalla con la que
el usuario puede interactuar, por ejemplo, marcar un número de teléfono, tomar una foto,
enviar un correo, ver un mapa. A cada actividad se le provee de una ventana para dibujar su
interfaz gráfica.

La actividad, es el componente esencial de una aplicación de Android, una aplicación suele

constar de varias actividades que realizan tareas específicas, aunque pueden ser tan
sencillas que solo requieran una sola actividad. Nuestras aplicaciones pueden interactuar
con otras aplicaciones que a su vez están compuestas de actividades.

Una actividad es una clase que extiende de android.app.Activity.

Ciclo de vida de las actividades

Las actividades en el sistema son manejadas como una pila de actividades. Cuando una
nueva actividad arranca, se posiciona encima de la pila y se convierte en la actividad que
está corriendo, la actividad anterior siempre permanece debajo de la actividad principal en
la pila y no estará en el tope otra vez hasta que la nueva actividad se cierre.

Las actividades pasan por tres estados:

 Resumida: La actividad esta en el frente de la pantalla y el usuario tiene el foco, se

dice que la actividad está corriendo.
 Pausada: Otra actividad está en el frente y tiene el foco, pero nuestra actividad
sigue visible. En el programa de ejemplo se puede ver este estado al mandar mostrar
un diálogo, que corre encima de la actividad principal pero no lo cubre
completamente.
 Detenida: Otra actividad corre completamente encima de la nuestra, es decir, está
“en el background”. Una actividad detenida sigue viva, es decir, aun ocupa un
espacio en memoria pero ya no es visible y puede ser destruida en cualquier
momento por el sistema si necesita la memoria.

El siguiente diagrama muestra las transiciones entre estados de una actividad. Los
rectángulos representan los métodos que podemos sobrescribir e implementar cuando hay
una transición de estados en la Actividad. Los óvalos de colores son los estados principales
de la actividad.
El ciclo de vida empieza cuando el usuario lanza la actividad y el sistema manda a llamar el
método onCreate(Bundle) de nuestra actividad y termina cuando el usuario cierra la
aplicación y se manda llamar el método onDestroy( ). La aplicación debe inicializar sus
recursos en el método onCreate y liberarlos en onDestroy.

La actividad es visible entre los métodos onStart( ) y onStop( ). Durante este tiempo la
aplicación es visible aunque el usuario no puede interactuar con ella.

La actividad está corriendo después de que se llama el método onResume( ) y sigue así
hasta que entra el método onPause( ). Durante este tiempo la actividad está frente a las
demás actividades y el usuario puede interactuar con ella. Las aplicaciones constantemente
van entre resumidas y pausadas, por ejemplo cuando el dispositivo “se duerme” o cuando
se despliega otra actividad.

La actividad termina cuando se manda llamar al método finish( ), este método finaliza la
actividad y el sistema manda llamar la función onDestroy( ).

Algo muy importante a resaltar, es que para cambiar de estados en nuestras actividades no
debemos mandar llamar directamente estos métodos, si no que es el sistema quien los
manda llamar.

Recuerda siempre mandar llamar super al implementar estos métodos.

Cómo programar una Actividad

Si estas usando eclipse puedes crear un archivo nuevo, seleccionas “otro”
y escoges “Android Activity”, eclipsé hará todo lo necesario por nosotros. Si no estamos
usando un editor tan amable o queremos aprender a crear actividades correctamente
sigamos estos pasos:

1. Crea una clase y extiende android.app.Activity.

2. Sobrescribe los métodos onCreate(Bundle) y onPause( ), estos dos son los más
importantes.

1
2
3
4
5 public class MiActividad {
6 public void onCreate(Bundle savedInstance)
7 {
//mi código de inicialización
8 super.onCreate(savedInstance);
9 //el layout/pantalla principal que vamos a mostrar
1 setContentView(view);
0 }
1
public void onPause()
1 {
1 super.onPause();
2 //liberar recursos
1 }
3 }
1
4
1
5
 3. Declara la actividad en el archivo AndroidManifest.xml, ubica el tag <application>
y agrega tu actividad ahí.

1<application
2<activity android:name="MyActividad"
3android:label="@string/titulo_actividad">
4</activity>
</application>
5

Retomando el punto 2, notarás que se manda llamar al método “setContentView”, este

método recibe de parámetro un layout con la pantalla principal. Para ver una inicialización
correcta de este método descarga la aplicación de ejemplo para este post.

Lanzando otras actividades

Como mencionamos antes, es lo más común que nuestras aplicaciones estén compuestas de
más de una actividad y, como ya dijimos también, nunca se deben mandar llamar los
métodos de callback directamente, por lo que para arrancar otra actividad no debemos
mandar llamar directamente su método onCreate( ); para esta tarea, Android nos provee de
la clase android.content.Intent y del método startActivity(Intent i), un Intent especifica la
actividad que queremos ejecutar, puede pertenecer a nuestra aplicación o bien a otra. El
Intent también puede contener parámetros usados por la aplicación a arrancar.

Para lanzar una actividad propia el código es muy sencillo:

1public void correOtraActividad()

2
3{
4
5Intent i = new Intent(this, OtraActividad.class);
6
7startActivity(i);
8
}
9

Habrá ocasiones en que nuestra actividad necesite hacer uso de ciertas aplicaciones del
sistema, como mandar un e-mail, SMS, usar la cámara, etc. No es necesario crear una
aplicación que tome fotos si Android ya nos provee de una aplicación que podemos mandar
llamar para realizar estas acciones, es aquí cuando los Intents son realmente útiles. Si
existen varias aplicaciones que puedan ejecutar la misma tarea el usuario puede seleccionar
cual usar.

Por ejemplo, si quieres mandar un correo puedes crear el siguiente Intent:

1Intent intent = new Intent(Intent.ACTION_SEND);

intent.putExtra(Intent.EXTRA_EMAIL, recipientArray);
2startActivity(intent);
3

Programa de ejemplo
Descarga el programa aquí.

Importa el proyecto a eclipse, instala y corre la aplicación.

La aplicación despliega los métodos involucrados en la transición de estados de las

actividades, consta de 3 actividades, una principal, una actividad hijo y un diálogo, este
último muestra cómo una actividad se puede pausar sin ser totalmente detenida.

Revisa los métodos onCreate de cada actividad. Nota como cada uno manda llamar al
método setContentView y pasa como parámetro el id de un layout de nuestra carpeta
res/layout/.

Examina los métodos closeActivity(View v) de la clase ChildActivity y finishDialog de

MyDialog. Estos métodos mandan llamar al método finish(), lo que finaliza la actividad
actual y manda llamar su método onDestroy(), regresando a la actividad anterior, en este
caso la actividad principal MainActivity.

Ahora examina el método doExit de la clase MainActivity, este también manda llamar a
finish(), en este caso, como no hay una actividad antes en la pila de actividades la actividad
actual se destruye y nuestra aplicación termina.

Analiza los layouts del proyecto en la carpeta res/layout/, abre activity_main.xml con un
editor de texto y observa el código que agrega los botones (el tag <Button>), observa en
sus propiedades la propiedad de android:onClick=”accion”. Esto indica el método que se
manda llamar al hacer clic en dicho botón, por ejemplo, el botón Exit manda llamar el
método doExit de la actividad principal.

Abre las actividades MainActivity y ChildActivity, analiza el método runDialog(View v),

observa el poco código que es requerido para lanzar otra actividad. El método
runChild(View v), manda llamar ejecutar la actividad ChildActivity, este solo aparece en la
clase MainActivity.

Corre la actividad hijo y el diálogo, observa el orden en que se ejecutan los métodos del
ciclo de vida de la actividad.
Activity – entender y usar una Actividad

Aquí vamos a extendernos para explicar completamente que es una actividad. Si quieres ir
directamente al código está al final. Y si no te sientes interesado por conocer
completamente qué es una actividad será mejor que mires en otros de los cientos de
tutoriales más directos que hay por Internet. Empecemos a comprender a fondo que es una
Activity de Android (Actividad en español).

Todos sabemos que es una aplicación informática. Pero por si lo hemos olvidado lo
resumo: una aplicación es un programa, que es una herramienta que permite al usuario
realizar algún que otro tipo de trabajo (estos trabajos pueden ser, editar un texto con una
herramienta de edición de textos, jugar a un juego, usar una calculadora, todo lo que se nos
ocurra). Y una aplicación internamente consta de código, así como ficheros que pueden ser
de audio, binarios, entre otros. Si, por ejemplo, una aplicación fuera “el Deporte”, esta
contendría internamente todos los deportes posibles como gimnasia rítmica, hacer
flexiones, bicicleta, correr, baloncesto, etc. Por cierto, la aplicaciones para dispositivos
móviles se llaman App -viene de convertir en chic y estilosa la palabra en inglés
“Application”, lo que es quedarnos con las tres primeras letras- es lo mismo con otro
nombre más modernamente guay.

Entre el código que nos encontramos, en Android, se usa el termino de Activity

(“Actividad” en español) para denominar a un tipo de clases java que heredan de Activity -
no te preocupes si no entendiste esto, lo explicaremos un poco más adelante. Una actividad,
como su propio nombre indica, es algo que el usuario puede hacer. El símil que se me
ocurre ahora mismo, con el ejemplo anterior, es el de actividad física, que es un conjunto de
movimientos del cuerpo que obtienen como resultado un gasto de energía. En Android una
actividad es lo mismo, es un conjunto de acciones (tocar la pantalla para apretar un botón,
para escribir con el teclado, etc) que son una iteración directa con el usuario y que afectan a
una parte de la aplicación. Para concretar más, vamos a suponer que nuestra actividad física
es correr -es una parte activa de la aplicación- con lo que nuestra actividad será correr.

Para entenderlo mejor, vamos a suponer que tenemos la App mencionada anteriormente se
llama “el Deporte”. Esta tiene actividades en su interior que son:

 Correr
 Baloncesto
 Flexiones

Con éstas nos vale para ejemplificar lo que queremos, podría haber más o menos como se
mencionó antes.
Lo que queremos hacer es correr, con lo que lanzamos nuestra actividad de correr.
Actividad que estará en primero plano y que contará con un ciclo de vida.

Una actividad se caracteriza por tener un ciclo de vida. Un ciclo de vida, al igual que el
ciclo vida de un animal: nace, crece, come, se reproduce y muere; también, es semejante en
una actividad. De la actividad de correr tendría el siguiente ciclo de vida: estiramos antes de
empezar a correr, comenzamos a correr, corremos a tope, en cierto momento decidimos
hacer una pausa para hacer flexiones, luego podemos decidir continuar con la carrera, y en
otro momento dejamos correr para otro día. El siguiente diagrama (modificación del oficial
para realizar el ejemplo, diagrama oficial que mostramos más adelante) muestra como se
desarrolla el ciclo de vida de la actividad de correr. Échale un vistazo rápido y continúa
leyendo la explicación:
 Como habrás visto, el ciclo de vida no es del todo lineal, sino que podemos tomar
decisiones y actuaremos en consecuencia, por ejemplo, podemos decidir hacer un descanso
y luego continuar corriendo o terminar. Pero lo que es lineal es lineal (en el ciclo de vida
animal es lineal comer antes de hacer cacotas, si no se come lo segundo es imposible de
conseguir), siempre calentaremos antes de correr, sino no es un deporte –decidir saltarnos
el calentamiento no elimina la linealidad, el calentamiento no se puede hacer mientras se
corre, o se hace antes o no se hace (por evitar dudas con el vocabulario, explicamos que
“calentar” siempre es antes de realizar un deporte, no después; para más dudas consular la
RAE).

Puede que existan preguntas acerca de los dos círculos rojos del diagrama, suelen llevar a
confusión, pero son completamente diferentes (También pueden darse dudas en algunos
estados como el de pausar y parar, pero esos y otros que puedan suscitar dudas se
esclarecerán en cuanto veamos un poco más adelante como funciona ese ciclo de vida en
formato App):

 El que “mata a la actividad” lo hace porque algo más importante requiere nuestra
atención absoluta, y no tenemos tiempo para seguir corriendo. No se decide
terminar de correr pero se acaba. Retomaremos la actividad de correr desde el
principio cuando queramos.
 El que “concluye a la actividad” es porque decidimos terminar de correr, entonces
acabamos la actividad.

Hemos comentado otras dos actividades: hacer flexiones y baloncesto. En cierto momento
del ciclo de vida de la actividad de correr, podemos decidir hacer la actividad de hacer
flexiones. Con lo que ponemos en segundo plano a la actividad de correr y empezamos con
la de hacer flexiones –decir que la actividad de hacer flexiones también tiene su propio

ciclo de vida que no dibujaremos por ser innecesario, te lo imaginas 😉 . La actividad de

baloncesto también tiene su propio ciclo de vida, pero en este ejemplo nunca será puesto en
marcha –simplemente hemos puesto la actividad de baloncesto para ejemplificar que puede
haber actividades que nunca se ejecuten.

Ahora vuelve al gráfico anterior e imagínate que has salido a correr, haz un recorrido
mental por el ciclo de vida de la actividad de correr y verás como todo va cobrando sentido.

Cuando acabes mira el siguiente ciclo de vida del mismo diagrama de ejemplo (el diagrama
es una modificación del oficial que mostramos un poco más adelante, paciencia), ésta vez
suponiendo que es una App de verdad en un Smartphone o Tablet. A la que observamos el
siguiente diagrama, imagínate que tienes instalada la aplicación “El Deporte”, y que te
dispones a arrancar la actividad de correr en tu móvil, que la vas a ver en la pantalla, vas a
poder tocar, e interactuar directamente; esta va a ser la actividad activa.
 Si pensamos en todo lo que podemos hacer con nuestro móvil teniendo la aplicación en
marcha, y delante de nosotros la actividad de correr en ejecución es posiblemente (éstas no
son las únicas acciones, otras también desencadenarán los mismos caminos por el ciclo de
vida):

 Arrancar la actividad: Pasará por Crear, Empezar y Continuar, para llegar a la

ejecución normal.
 Usar de manera normal la actividad: estamos en la actividad en ejecución.
  Una ventana emergente se ha abierto: Pasará por Pausar.
 Cambiar a otra actividad o bloquear el móvil: Pasará por Pausar y Parar. (Nota
aclaratoria: si se cambia a otra actividad pasa necesariamente por pausar y parar, no
ha tenido que surgir una ventana emergente para pasar por pausar, si se cambia de
actividad se pasa por ambos estados directamente; esto se da con otras acciones que
pasen por varios estados).
 Apagar el móvil: Pasará por Pausar, Parar y Destruir.

Entendido esto veamos el ciclo oficial de una actividad (así como los anteriores gráficos
son una modificación ofrecida por www.Jarroba.com para ejemplificar sobre el oficial, el
siguiente gráfico es un traducción del oficial de Android, el diagrama oficial está disponible
en http://developer.android.com/reference/android/app/Activity.html).
 Empezamos a hablar en términos de programación. Como vemos en los recuadros existen
varios métodos con nombres en inglés iguales a los que explicamos anteriormente. Estos
métodos están en la clase Activity, clase que tendremos que heredar para que nuestra clase
se convierta en una actividad de la siguiente forma (Nota: hasta que no avise de lo
contrario, esto es código no funcional, con lo justo para entender la teoría; aviso más
adelante cuando aparezca el código funcional):

public class Correr extends Activity {

//Aquí estará contenido de toda la actividad de Correr
}

Podemos añadir opcionalmente cada uno de los métodos para sobrescribirlos (esto lo indica
el @Override) a la clase padre Activity, no siendo obligatorio ninguno. Dentro
escribiremos el código que queramos que se ejecute, y cada método será llamado por la
clase Activity en el momento indicado anteriormente. A continuación escribimos todos los
métodos posibles, los que no necesitemos ni los escribimos. No ponerlos no les priva de
existencia, siguen existiendo en la clase Activity, por tanto en el ciclo de vida de nuestra
Actividad, pero al ejecutarse a su momento estarán vacíos.

public class actividad_de_correr extends Activity {

@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
//Nuestro código a ejecutar en este momento
}

@Override
public void onStart(){
super.onStart();
//Nuestro código a ejecutar en este momento
}

@Override
public void onRestart(){
super.onRestart();
//Nuestro código a ejecutar en este momento
}

@Override
public void onResume(){
super.onResume();
//Nuestro código a ejecutar en este momento
}

@Override
public void onPause(){
super.onPause();
//Nuestro código a ejecutar en este momento
}

@Override
public void onStop(){
super.onStop();
//Nuestro código a ejecutar en este momento
}

@Override
public void onDestroy(){
super.onDestroy();
//Nuestro código a ejecutar en este momento
}

}
Para empezar, recomiendo usar únicamente el método onCreate, que es el que se ejecuta al
arrancar la actividad, el resto de métodos los emplearemos en caso de necesitarlos.

Si te preguntas para que se usa el resto de métodos, imagínate un juego en nuestro móvil.
Estamos jugando y en cierto momento nos da por apagar el móvil. Para no perder el
progreso, en el onDestroy recolectamos los datos de la partida y los guardamos en la
memoria persistente. Así la próxima vez que juguemos, en el onCreate preguntará a la
memoria si existen datos guardados del juego, y cargará la partida en el mismo instante en
la que la dejamos.

public class actividad_de_correr extends Activity {

@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
//Nuestro código a ejecutar en este momento
}

A partir de aquí expondremos un ejemplo con código completamente funcional.

Realizaremos la aplicación “El_Deporte”. Dentro contendrá dos actividades: Correr y
Flexiones (quitamos la de baloncesto por simplificar el código). Creamos un nuevo
proyecto de Android, le ponemos el nombre de la aplicación “El_Deporte” y pulsamos todo
el rato a “Next” hasta terminar, así tener le proyecto listo para trabajar.
Vamos a la carpeta “res” y ahí a la carpeta “layout” y creamos dos xml.

Uno llamado “layout_correr.xml” con el siguiente código (como construir y entender este
código xml lo explicaremos en otro tutorial, aquí nos lo creemos):

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

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:gravity="center"
android:orientation="vertical" >

<TextView
android:id="@+id/textView1"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Estamos corriendo"
android:textAppearance="?android:attr/textAppearanceLarge" />

<Button
android:id="@+id/button_flexiones"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Ponerse a hacer Flexiones"
android:onClick="clicEnBoton_IrAFlexiones"
/>

</LinearLayout>

Este layout muestra al usuario:

Y otro “layout_flexiones.xml”, con el siguiente código:

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

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:gravity="center"
android:orientation="vertical" >

<TextView
android:id="@+id/textView1"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Estamos haciendo Flexiones"
android:textAppearance="?android:attr/textAppearanceLarge" />

</LinearLayout>
Este otro muestra por pantalla:

Por norma general, una actividad está asociada a un Layout. Un Layout es la ventana o
vista que el usuario ve en la pantalla: botones, textos, barras de desplazamiento, etc. La
asociación se hace en el onCreate con el método llamado "setContentView", como veremos
en el siguiente código.

Si has visto algo del patrón Modelo-Vista-Controlador, decirte que lo que llamamos en
Android Layout es la Vista, la Activity debería de ser el Modelo, y el resto de clases
actuarán de Controlador.

Creamos una nueva actividad que llamamos “Correr” y ponemos el siguiente código.

package com.example.el_deporte;

import android.app.Activity;
import android.content.Intent;
import android.os.Bundle;
import android.view.View;

public class Correr extends Activity {

@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.layout_correr);
}

public void clicEnBoton_IrAFlexiones (View view) {

Intent intent = new Intent(this, Flexiones.class);
startActivity(intent);
}

Aquí tenemos el onCreate al que se le pasa por parámetro una variable que se llama
“savedInstanceState” de tipo “Bundle”. Esto lo explicaremos en otro tutorial más
extendidamente. Pero para que vayas tomando conceptos un resumen rápido: un Bundle
son datos que le pasamos a esta actividad para inicializar su estado. En este ejemplo no lo
usamos, pero si pensamos por ejemplo en un juego, en el que se pide en una actividad el
sexo del personaje, y pasamos a la siguiente actividad, en el que se ve nuestro personaje
con el sexo elegido; el sexo como variable hombre o mujer ha tenido que ser pasado de
algún modo de una actividad a otra, se hace con “Bundle”.

El onCreate requiere iniciar al padre antes de todo, de ahí la línea:

super.onCreate(savedInstanceState);
En la línea siguiente establecemos que Layout queremos asociar a esta actividad, como es
la actividad “correr”, es justo asociarle el layout “layout_correr”, se hace como se muestra
en: setContentView(R.layout.layout_correr);

Existe otro método normal y corriente llamado “cliclEnBoton_IrAFelxiones” que es el que

se ejecuta cuando hacemos clic en el botón con el texto “Ponerse a hacer Flexiones”. Este
se llama desde el propio xml en la línea android:onClick="clicEnBoton_IrAFlexiones" y lo
que hace es que al pulsar el botón, este método se ejecute.

Este método lo único que hace es abrir la otra actividad “Flexiones”. Se hace con algo
llamado “Intent”. Un “Intent” es declarar la intención de lo que se quiere hacer, en este
caso la intención es ejecutar la actividad Flexiones –aunque podría decir que además de
abrir otra actividad lo que queremos es también pasar ciertos datos como en el ejemplo
anterior del juego con el sexo. Dicho de otro modo, un “Intent” es un paquete con todo lo
que queramos configurar la nueva activity a ejecutar. Solo falta decir que el “this” es el
contexto de la actividad actual (para saberlo todo sobre el Context mira este artículo). Esto
lo realiza el código: Intent intent = new Intent(this, Flexiones.class);

Después de declarar la intención hay que lanzar la actividad con: startActivity(intent);

Para llegar a la siguiente actividad y Layout asociado necesitamos su código. Creamos otra
nueva actividad que llamamos “Flexiones” con este código:

package com.example.el_deporte;

import android.app.Activity;
import android.os.Bundle;

public class Flexiones extends Activity {

@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.layout_flexiones);
}

Así cuando lleguemos a esta actividad, se mostrará por pantalla el Layout correspondiente.

Pero existe un problema de seguridad que hará que la aplicación falle si intentamos esto sin
más. Nos queda modificar el fichero llamado “AndroidManifest.xml”. Este fichero es el
encargado de manejar los permisos de la aplicación, y aquí hay que declarar todo lo que
nuestra aplicación pueda suponer un problema de seguridad. En este Manifiesto, tendremos
que poner si nuestra aplicación hará uso de Internet, si va a poder realizar llamadas, etc;
estos son los permisos que el usuario tiene que aceptar cuando el usuario se dispone a
instalar una aplicación. La apertura de actividades tiene que estar controlado desde este
fichero.
Para ello vamos al “AndroidManifest.xml”. En la pestaña “Application”, en el apartado
“Application Nodes” pulsamos el botón “Add…”.

En la ventana que se nos abre, nos aseguramos que esté marcada la casilla “Create a new
element at the top level, in Application”. Elegimos “Activity” y pulsamos “OK”.

Ahora, aseguramos que tenemos seleccionada el nuevo nodo que hemos creado que se
llama “Activity”. Estarán todos sus campos correspondientes a la derecha en blanco,
pulsamos en Name en el botón “Browse…”.
Otra ventana nueva se nos abrirá. Esperamos unos segundos a que carguen todas las
actividades que tenemos –un porcentaje nos avisará de ello- y seleccionamos la actividad
que deseamos, en este ejemplo “Flexiones”. Acabamos pulsando “OK”.

Guardamos el fichero “AndroidManifest.xml” y ya está. A continuación una pantalla de

cómo queda finalmente:
 Con lo que hemos hecho en el "AndroidManifest.xml" lo único que hemos hecho es añadir
la siguiente línea a su XML:

<activity android:name="Flexiones"></activity>

Si abrimos el XML del "AndroidManifest.xml" nos habrá quedado una estructura parecida
a la que sigue:

<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="com.example.el_deporte"
android:versionCode="1"
android:versionName="1.0" >

<uses-sdk
android:minSdkVersion="8"
android:targetSdkVersion="15" />

<application
android:icon="@drawable/ic_launcher"
android:label="@string/app_name"
android:theme="@style/AppTheme" >
<activity
android:name=".Correr" android:label="">
<intent-filter>
<action android:name="android.intent.action.MAIN" />

<category android:name="android.intent.category.LAUNCHER"
/>
</intent-filter>
</activity>
<activity android:name="Flexiones"></activity>
</application>

</manifest>
Ya podemos ejecutar nuestra aplicación en el emulador y probar como hemos hecho una
actividad que al pulsar el botón se pasa a la otra. Como llevamos diciendo en el ejemplo de
correr, estamos corriendo en la siguiente pantalla:

Pulsamos el botón de “Ponerse a hacer Flexiones” y pausamos la actividad de Correr para

arrancar la actividad de Flexiones.
Para volver a la actividad anterior pulsamos el botón de atrás del dispositivo, con lo que la
actividad de Correr continuará.

Puedes descargarte el proyecto entero desde aquí: Descargar App El_Deporte

Esperamos que te haya esclarecido lo relacionado con todo lo relacionado sobre actividades
de Android, ya que es lo más gordo que tiene -y más importante- requiere ser bien
entendido. Para cualquier pregunta o aclaración en un comentario que responderemos lo
antes posible.

Recomiendo que prosigas con el estudio de Android en el siguiente artículo sobre el

Context pinchando aquí, donde explicamos en profundidad qué es y para qué sirve.

Ver en vivo como funciona el ciclo de vida de una actividad:Para probar como funciona
el ciclo de vida de una actividad, lo mejor es verlo por nosotros mismos. Para ello
sustituimos la actividad Correr por el siguiente código, donde se muestran todos los estados
por los que puede pasar:

package com.example.el_deporte;

import android.app.Activity;
import android.content.Intent;
import android.os.Bundle;
import android.view.View;
import android.util.Log;

public class Correr extends Activity {

@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.layout_correr);
Log.v("test", "Create");
}

public void clicEnBoton_IrAFlexiones (View view) {

Intent intent = new Intent(this, Flexiones.class);
startActivity(intent);
}

@Override
public void onStart(){
super.onStart();
Log.v("test", "Start");
}

@Override
public void onRestart(){
super.onRestart();
Log.v("test", "Restart");
 }

@Override
public void onResume(){
super.onResume();
Log.v("test", "Resume");
}

@Override
public void onPause(){
super.onPause();
Log.v("test", "Pause");
}

@Override
public void onStop(){
super.onStop();
Log.v("test", "Stop");
}

@Override
public void onDestroy(){
super.onDestroy();
Log.v("test", "Destroy");
}

Hemos añadido a este código un log en cada método del ciclo de vida para poder ver por el
LogCat de Android la salida.

Trastear un poco con esto nos hará entender como funciona el ciclo de vida de una
actividad.

Por ejemplo:

1º Supongamos que arrancamos la aplicación, se cargará la actividad de Correr, y por el

LogCat se nos mostrará en cada línea: Create, Start y Resume.

2º Ahora pulsamos el botón, como otra actividad se nos pone encima ocultándola
completamente, se mostrará en este orden: Pause y Stop.

3º Si pulsamos el botón de volver, retomamos la actividad de Correr y se mostrará: Restart,

Start y Resume.

4º Si pulsamos el botón de inicio para volver al escritorio, se nos mostrará: Pause y Stop.

Podemos hacer todas las pruebas que queramos, para entender perfectamente el ciclo de
vida de la actividad. Es recomendable que eches un vistazo al diagrama para poder seguir la
vida de una actividad.