Activity — cos'è, schermata dell'app in Android e suo Lifecycle

Cos'è Activity?

Activity — un componente chiave di un'applicazione Android che fornisce una finestra per l'interazione con l'utente. Ogni Activity gestisce una schermata separata: elenco attività, modulo di accesso, visualizzatore foto. Il sistema Android crea un'Activity su richiesta e la distrugge quando altre applicazioni necessitano di memoria.

Activity è apparsa per la prima volta in Android 1.0 (2008) e rimane il principale blocco costruttivo dell'interfaccia. Secondo Google (2026), il 98% delle applicazioni su Google Play contiene almeno un'Activity. Nell'architettura moderna, Google raccomanda un'Activity con più Fragment, tuttavia l'applicazione classica multi-schermo rimane una pratica comune.

Activity stack (back stack) — una pila di attività che memorizza la cronologia di navigazione. Quando l'utente preme "Indietro", l'Activity corrente viene distrutta e quella precedente viene ripristinata. Il sistema gestisce la pila automaticamente, ma lo sviluppatore può controllare il comportamento tramite launchMode e flag Intent.

Ciclo di vita di Activity

Il ciclo di vita di Activity è un insieme di stati e callback attraverso cui uno schermo passa dalla creazione alla distruzione. Comprendere il Lifecycle è di fondamentale importanza: una gestione errata degli stati porta a perdite di memoria, perdita di dati e crash dell'applicazione.

Il sistema Android chiama i callback in un ordine rigoroso. Lo sviluppatore sovrascrive i metodi necessari per inizializzare risorse, salvare dati e liberare memoria. Ogni callback ha una coppia corrispondente: onCreate ↔ onDestroy, onStart ↔ onStop, onResume ↔ onPause.

Stati di Activity

Esistono quattro stati di Activity: Running (onResume attivo), Paused (visibile ma senza focus), Stopped (non visibile), Destroyed (distrutto). Il sistema può terminare un'Activity in stato Stopped in caso di memoria insufficiente — i dati devono essere salvati in onSaveInstanceState.

Metodi del ciclo di vita: onCreate, onStart, onResume

Esaminiamo tre metodi chiave del ciclo di vita di Activity con un esempio in Kotlin. onCreate — il punto di ingresso, chiamato una sola volta. Qui avvengono il binding del layout tramite setContentView, l'inizializzazione di RecyclerView, la sottoscrizione a LiveData. onStart — l'Activity diventa visibile all'utente. onResume — l'Activity ottiene il focus ed è pronta per l'interazione.

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()
    }
}

Nell'esempio, onCreate inizializza RecyclerView e carica i dati. onStart avvia gli aggiornamenti di geolocalizzazione — una risorsa che dovrebbe funzionare solo quando lo schermo è visibile. onResume riprende il video che è stato messo in pausa in onPause. Questa separazione previene lavoro non necessario in background.

Dichiarazione di Activity in AndroidManifest.xml

Ogni Activity deve essere dichiarata nel file AndroidManifest.xml. Senza registrazione, il sistema non troverà la schermata e lancerà un'eccezione ActivityNotFoundException. Il manifest specifica il nome della classe, il tema, l'orientamento, launchMode e i filtri 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>

Il flag exported determina se altre applicazioni possono avviare l'Activity. Per la schermata principale exported=true, per le schermate interne — false. L'attributo parentActivityName abilita la navigazione standard "Su" (Up Navigation).

Avviare Activity tramite Intent

Intent — un oggetto che descrive un'azione da eseguire. Nel contesto di Activity, Intent viene utilizzato per avviare un'altra schermata con trasferimento dati. Intent può essere esplicito (specifica una classe concreta) e implicito (specifica un'azione, il sistema seleziona un componente adatto).

// Intent esplicito — avviare DetailActivity con dati
val intent = Intent(this, DetailActivity::class.java).apply {
    putExtra("item_id", itemId)
    putExtra("item_name", itemName)
}
startActivity(intent)

// Ottenere dati in DetailActivity
val itemId = intent.getLongExtra("item_id", 0L)
val itemName = intent.getStringExtra("item_name") ?: ""

Per ottenere un risultato da un'Activity avviata, si utilizza Activity Result API, che ha sostituito il deprecato startActivityForResult. La nuova API è type-safe, dichiarativa e funziona 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)
}

Salvare lo stato durante la ricreazione

Durante la rotazione dello schermo o il cambio di configurazione, Android ricrea l'Activity — chiama sequenzialmente onDestroy e onCreate. Senza salvare lo stato, l'utente perde i dati inseriti, la posizione di scorrimento e gli elementi selezionati. Android fornisce due meccanismi per risolvere questo problema: onSaveInstanceState e ViewModel.

onSaveInstanceState salva dati semplici in Bundle prima della chiamata a onDestroy. ViewModel di Jetpack sopravvive alla ricreazione di Activity e memorizza i dati in memoria, risultando più efficiente per oggetti complessi e richieste di rete.

class MainActivity : AppCompatActivity() {

    private val viewModel: MainViewModel by viewModels()

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

        // ViewModel salva automaticamente i dati
        viewModel.items.observe(this) { items ->
            updateAdapter(items)
        }
    }

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

Architettura Single Activity e Jetpack

L'approccio moderno di Google è l'architettura Single Activity con un'Activity e più Fragment. L'app utilizza una MainActivity e tutta la navigazione è gestita da Navigation Component tramite NavHostFragment. Vantaggi: navigazione centralizzata, ViewModel condiviso per schermata, gestione corretta dei Deep Links.

Jetpack Navigation Component automatizza la gestione del back stack, le animazioni di transizione e il passaggio di argomenti. NavHostFragment viene posizionato nel layout dell'Activity e il grafo di navigazione (NavGraph) descrive tutte le schermate e le connessioni tra loro. Questo approccio è raccomandato da Google per i nuovi progetti e segue i principi di 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)

        // Configurazione di NavigationUI per AppBar
        setupActionBarWithNavController(navController)
    }

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