---
title: Activity – entender y usar una Actividad
url: https://jarroba.com/activity-entender-y-usar-una-actividad/
author: Ramón Invarato
date: 2012-11-04
modified: 2026-10-21
language: es
license: CC BY-NC-SA 3.0 (https://creativecommons.org/licenses/by-nc-sa/3.0/) — attribution: "Activity – entender y usar una Actividad", Ramón Invarato, jarroba.com
categories: Aplicaciones Móviles
---
# Activity – entender y usar una Actividad
> Qué es una Activity de Android, cómo es su ciclo de vida y cómo abrir una actividad desde otra con un Intent y el AndroidManifest, con un ejemplo completo.
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 qué 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, las aplicaciones para dispositivos móviles se llaman **App** -viene de convertir en chic y estilosa la palabra en inglés “**App**lication”, 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 interacció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 que 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 primer 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:
[](https://jarroba.com/wp-content/uploads/2012/11/Ciclo-de-Vida-de-Activity-de-Ejemplo-para-entender-qué-es-una-actividad-www.Jarroba.com_.png)
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, si no 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 consultar 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.
[](https://jarroba.com/wp-content/uploads/2012/11/Ciclo-de-Vida-para-enlazar-el-ejemplo-anterior-con-el-oficial-www.Jarroba.com_.png)
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 [Activity — API reference (Android Developers)](http://developer.android.com/reference/android/app/Activity.html)).
[](https://jarroba.com/wp-content/uploads/2012/11/Ciclo-de-Vida-de-Activity-Oficial-Traducido-www.Jarroba.com_.png)
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):
```java
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.
```java
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.
```java
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 el proyecto listo para trabajar.
[](https://jarroba.com/wp-content/uploads/2012/11/Pantala-de-nuevo-proyecto-AndroidAprender-a-usar-el-AndroidManifest-1-www.Jarroba.com_.png)
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
```
Este layout muestra al usuario:
[](https://jarroba.com/wp-content/uploads/2012/11/Ejemplo-de-un-Layout-1-www.Jarroba.com_.png)
Y otro “layout_flexiones.xml”, con el siguiente código:
```xml
```
Este otro muestra por pantalla:
[](https://jarroba.com/wp-content/uploads/2012/11/Ejemplo-de-un-Layout-2-www.Jarroba.com_.png)
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.
```java
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](https://jarroba.com/context-de-android/)). 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:
```java
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…”.
[](https://jarroba.com/wp-content/uploads/2012/11/Aprender-a-usar-el-AndroidManifest-1-www.Jarroba.com_.png)
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”.
[](https://jarroba.com/wp-content/uploads/2012/11/Aprender-a-usar-el-AndroidManifest-2-www.Jarroba.com_.png)
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…”.
[](https://jarroba.com/wp-content/uploads/2012/11/Aprender-a-usar-el-AndroidManifest-3-www.Jarroba.com_.png)
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”.
[](https://jarroba.com/wp-content/uploads/2012/11/Aprender-a-usar-el-AndroidManifest-4-www.Jarroba.com_.png)
Guardamos el fichero “AndroidManifest.xml” y ya está. A continuación una pantalla de cómo queda finalmente:
[](https://jarroba.com/wp-content/uploads/2012/11/Aprender-a-usar-el-AndroidManifest-5-www.Jarroba.com_.png)
Con lo que hemos hecho en el "AndroidManifest.xml" lo único que hemos hecho es añadir la siguiente línea a su XML:
```xml
```
Si abrimos el XML del "AndroidManifest.xml" nos habrá quedado una estructura parecida a la que sigue:
```xml
```
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:
[](https://jarroba.com/wp-content/uploads/2012/11/Ejemplo-de-una-Actividad-1-www.Jarroba.com_.png)
Pulsamos el botón de “Ponerse a hacer Flexiones” y pausamos la actividad de Correr para arrancar la actividad de Flexiones.
[](https://jarroba.com/wp-content/uploads/2012/11/Ejemplo-de-una-Actividad-2-www.Jarroba.com_.png)
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](https://jarroba.com/wp-content/uploads/2012/11/El_Deporte.rar)
Esperamos que te haya esclarecido 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](https://jarroba.com/context-de-android/)í, 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:
```java
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.