Activity — ce este, ecranul aplicației în Android și Lifecycle-ul său

Ce este Activity?

Activity — componenta cheie a aplicației Android, oferind o fereastră pentru interacțiunea cu utilizatorul. Fiecare Activity gestionează un ecran separat: lista de sarcini, formularul de autentificare, vizualizarea foto. Sistemul Android creează Activity la cerere și îl distruge când memoria este necesară altor aplicații.

Activity a apărut pentru prima dată în Android 1.0 (2008) și rămâne blocul principal de construcție al interfeței. Conform Google (2026), 98% din aplicațiile din Google Play conțin cel puțin un Activity. În arhitectura modernă, Google recomandă un Activity cu mai multe Fragment, însă aplicația clasică cu mai multe ecrane rămâne o practică răspândită.

Activity stack (back stack) — stiva de sarcini care stochează istoricul navigării. Când utilizatorul apasă „Înapoi”, Activity-ul curent este distrus și cel anterior este restaurat. Sistemul gestionează stiva automat, dar dezvoltatorul poate controla comportamentul prin launchMode și flag-uri Intent.

Ciclul de viață al Activity

Ciclul de viață al Activity — setul de stări și callback-uri prin care trece ecranul de la creare la distrugere. Înțelegerea Lifecycle este critică: lucrul incorect cu stările duce la scurgeri de memorie, pierderi de date și crash-uri ale aplicației.

Sistemul Android apelează callback-urile într-o ordine strictă. Dezvoltatorul suprascrie metodele necesare pentru a inițializa resurse, a salva date și a elibera memoria. Fiecărui callback îi corespunde o pereche: onCreate ↔ onDestroy, onStart ↔ onStop, onResume ↔ onPause.

Stările Activity

Se disting patru stări ale Activity: Running (onResume activ), Paused (vizibil, dar fără focalizare), Stopped (invizibil), Destroyed (distrus). Sistemul poate kill-ui Activity în starea Stopped la lipsa de memorie — datele trebuie salvate în onSaveInstanceState.

Metodele ciclului de viață: onCreate, onStart, onResume

Să examinăm trei metode cheie ale ciclului de viață Activity cu un exemplu în Kotlin. onCreate — punctul de intrare, apelat o singură dată. Aici are loc legarea layout-ului prin setContentView, inițializarea RecyclerView, abonarea la LiveData. onStart — Activity devine vizibil pentru utilizator. onResume — Activity primește focalizarea și este gata de interacțiune.

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

În exemplu, onCreate inițializează RecyclerView și încarcă datele. onStart pornește actualizarea geolocației — o resursă care ar trebui să funcționeze doar când ecranul este vizibil. onResume reia videoclipul oprit în onPause. O astfel de separare previne munca inutilă în fundal.

Declararea Activity în AndroidManifest.xml

Fiecare Activity trebuie declarat în fișierul AndroidManifest.xml. Fără înregistrare, sistemul nu va găsi ecranul și va arunca excepția ActivityNotFoundException. În manifest se specifică numele clasei, tema, orientarea, launchMode și filtrele 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>

Indicatorul exported determină dacă alte aplicații pot lansa Activity. Pentru ecranul principal exported=true, pentru ecranele interne — false. Atributul parentActivityName activează navigarea standard „În sus” (Up Navigation).

Lansarea Activity prin Intent

Intent — un obiect care descrie o acțiune de executat. În contextul Activity, Intent este folosit pentru a lansa un alt ecran cu transmiterea de date. Intent poate fi explicit (indică o clasă specifică) și implicit (indică o acțiune, sistemul selectează componentul potrivit).

// Intent explicit — lansarea DetailActivity cu date
val intent = Intent(this, DetailActivity::class.java).apply {
    putExtra("item_id", itemId)
    putExtra("item_name", itemName)
}
startActivity(intent)

// Primirea datelor în DetailActivity
val itemId = intent.getLongExtra("item_id", 0L)
val itemName = intent.getStringExtra("item_name") ?: ""

Pentru a primi rezultatul de la Activity-ul lansat se folosește Activity Result API, care a înlocuit startActivityForResult învechit. Noul API este type-safe, declarativ și funcționează cu 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)
}

Salvarea stării la recreare

La rotirea ecranului sau schimbarea configurației, Android recrează Activity — apelează secvențial onDestroy și onCreate. Fără salvarea stării, utilizatorul pierde datele introduse, poziția de scroll și elementele selectate. Pentru a rezolva această problemă, Android oferă două mecanisme: onSaveInstanceState și ViewModel.

onSaveInstanceState salvează date simple în Bundle înainte de apelarea onDestroy. ViewModel din Jetpack rezistă la recrearea Activity și păstrează datele în memorie, ceea ce este mai eficient pentru obiecte complexe și cereri de rețea.

class MainActivity : AppCompatActivity() {

    private val viewModel: MainViewModel by viewModels()

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

        // ViewModel salvează automat datele
        viewModel.items.observe(this) { items ->
            updateAdapter(items)
        }
    }

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

Arhitectura Single Activity și Jetpack

Abordarea modernă Google — arhitectura Single Activity cu un Activity și mai multe Fragment. Aplicația folosește un MainActivity, iar toată navigarea este realizată de Navigation Component prin NavHostFragment. Avantaje: navigare centralizată, ViewModel comun pe ecran, lucru corect cu Deep Links.

Jetpack Navigation Component automatizează lucrul cu back stack, animațiile de tranziție și transmiterea argumentelor. NavHostFragment este plasat în layout-ul Activity, iar graful de navigare (NavGraph) descrie toate ecranele și conexiunile dintre ele. Această abordare este recomandată de Google pentru proiecte noi și corespunde principiilor 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)

        // Configurarea NavigationUI pentru AppBar
        setupActionBarWithNavController(navController)
    }

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