Activity — qué es, pantalla de aplicación en Android y su Lifecycle

¿Qué es Activity?

Activity — un componente clave de una aplicación Android que proporciona una ventana para la interacción con el usuario. Cada Activity gestiona una pantalla separada: lista de tareas, formulario de inicio de sesión, visor de fotos. El sistema Android crea una Activity cuando se solicita y la destruye cuando otros programas necesitan memoria.

Activity apareció por primera vez en Android 1.0 (2008) y sigue siendo el bloque de construcción principal de la interfaz. Según Google (2026), el 98% de las aplicaciones en Google Play contienen al menos una Activity. En la arquitectura moderna, Google recomienda una Activity con múltiples Fragments, sin embargo la aplicación clásica de múltiples pantallas sigue siendo una práctica común.

Activity stack (back stack) — una pila de tareas que almacena el historial de navegación. Cuando el usuario presiona "Atrás", la Activity actual se destruye y se restaura la anterior. El sistema gestiona la pila automáticamente, pero el desarrollador puede controlar el comportamiento mediante launchMode y banderas de Intent.

Ciclo de vida de Activity

El ciclo de vida de Activity es un conjunto de estados y callbacks a través de los cuales una pantalla pasa desde la creación hasta la destrucción. Comprender el Lifecycle es críticamente importante: el manejo incorrecto de estados conduce a fugas de memoria, pérdida de datos y fallos de la aplicación.

El sistema Android llama a los callbacks en un orden estricto. El desarrollador sobrescribe los métodos necesarios para inicializar recursos, guardar datos y liberar memoria. Cada callback tiene un par correspondiente: onCreate ↔ onDestroy, onStart ↔ onStop, onResume ↔ onPause.

Estados de Activity

Se distinguen cuatro estados de Activity: Running (onResume activo), Paused (visible pero sin foco), Stopped (no visible), Destroyed (destruido). El sistema puede eliminar una Activity en estado Stopped cuando falta memoria — los datos deben guardarse en onSaveInstanceState.

Métodos del ciclo de vida: onCreate, onStart, onResume

Veamos tres métodos clave del ciclo de vida de Activity con un ejemplo en Kotlin. onCreate — el punto de entrada, se llama una vez. Aquí ocurren la vinculación del layout mediante setContentView, la inicialización de RecyclerView, la suscripción a LiveData. onStart — la Activity se vuelve visible para el usuario. onResume — la Activity obtiene el foco y está lista para la interacción.

class MainActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        val recyclerView = findViewById<RecyclerView>(R.id.rv_items)
        recyclerView.layoutManager = LinearLayoutManager(this)
        loadItems()
    }

    override fun onStart() {
        super.onStart()
        startLocationUpdates()
    }

    override fun onResume() {
        super.onResume()
        resumeVideoPlayer()
    }
}

En el ejemplo, onCreate inicializa RecyclerView y carga datos. onStart inicia actualizaciones de geolocalización — un recurso que solo debe funcionar cuando la pantalla es visible. onResume reanuda el video que se pausó en onPause. Esta separación evita trabajo innecesario en segundo plano.

Declaración de Activity en AndroidManifest.xml

Cada Activity debe declararse en el archivo AndroidManifest.xml. Sin registro, el sistema no encontrará la pantalla y lanzará una excepción ActivityNotFoundException. En el manifiesto se especifican el nombre de la clase, tema, orientación, launchMode y filtros de Intent.

<application
    android:allowBackup="true"
    android:label="@string/app_name"
    android:theme="@style/Theme.MyApp">

    <activity
        android:name=".MainActivity"
        android:exported="true">
        <intent-filter>
            <action android:name="android.intent.action.MAIN" />
            <category android:name="android.intent.category.LAUNCHER" />
        </intent-filter>
    </activity>

    <activity
        android:name=".DetailActivity"
        android:parentActivityName=".MainActivity" />
</application>

El flag exported determina si otras aplicaciones pueden iniciar la Activity. Para la pantalla principal exported=true, para pantallas internas — false. El atributo parentActivityName habilita la navegación estándar "Arriba" (Up Navigation).

Iniciar Activity mediante Intent

Intent — un objeto que describe una acción a realizar. En el contexto de Activity, Intent se utiliza para iniciar otra pantalla con transferencia de datos. Intent puede ser explícito (especifica una clase concreta) e implícito (especifica una acción, el sistema selecciona un componente adecuado).

// Intent explícito — iniciar DetailActivity con datos
val intent = Intent(this, DetailActivity::class.java).apply {
    putExtra("item_id", itemId)
    putExtra("item_name", itemName)
}
startActivity(intent)

// Obtener datos en DetailActivity
val itemId = intent.getLongExtra("item_id", 0L)
val itemName = intent.getStringExtra("item_name") ?: ""

Para obtener un resultado de una Activity iniciada se utiliza Activity Result API, que reemplazó al obsoleto startActivityForResult. La nueva API es type-safe, declarativa y funciona con Jetpack Compose.

private val getResult = registerForActivityResult(
    ActivityResultContracts.StartActivityForResult()
) { result ->
    if (result.resultCode == Activity.RESULT_OK) {
        val data = result.data?.getStringExtra("result_key")
    }
}

fun openPicker() {
    val intent = Intent(this, PickerActivity::class.java)
    getResult.launch(intent)
}

Guardar estado al recrear

Al rotar la pantalla o cambiar la configuración, Android recrea la Activity — llama secuencialmente a onDestroy y onCreate. Sin guardar el estado, el usuario pierde los datos introducidos, la posición del scroll y los elementos seleccionados. Android proporciona dos mecanismos para resolver este problema: onSaveInstanceState y ViewModel.

onSaveInstanceState guarda datos simples en Bundle antes de llamar a onDestroy. ViewModel de Jetpack soporta la recreación de Activity y almacena datos en memoria, lo que es más eficiente para objetos complejos y solicitudes de red.

class MainActivity : AppCompatActivity() {

    private val viewModel: MainViewModel by viewModels()

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        // ViewModel guarda datos automáticamente
        viewModel.items.observe(this) { items ->
            updateAdapter(items)
        }
    }

    override fun onSaveInstanceState(outState: Bundle) {
        super.onSaveInstanceState(outState)
        outState.putInt("scroll_position", recyclerView.computeVerticalScrollOffset())
    }
}

Arquitectura Single Activity y Jetpack

El enfoque moderno de Google es la arquitectura Single Activity con una Activity y múltiples Fragments. La aplicación utiliza una MainActivity, y toda la navegación se gestiona mediante Navigation Component a través de NavHostFragment. Ventajas: navegación centralizada, ViewModel compartido por pantalla, manejo correcto de Deep Links.

Jetpack Navigation Component automatiza la gestión del back stack, las animaciones de transición y el paso de argumentos. NavHostFragment se coloca en el layout de Activity, y el grafo de navegación (NavGraph) describe todas las pantallas y conexiones entre ellas. Este enfoque está recomendado por Google para nuevos proyectos y sigue los principios de Material Design.

class MainActivity : AppCompatActivity() {

    private val navController by lazy {
        findViewById<NavHostFragment>(R.id.nav_host_fragment)
            .navController
    }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        // Configuración de NavigationUI para AppBar
        setupActionBarWithNavController(navController)
    }

    override fun onSupportNavigateUp() = 
        navController.navigateUp() || super.onSupportNavigateUp()
}