Activity — mi ez, alkalmazásképernyő Androidban és Lifecycle-je

Mi az Activity?

Activity — az Android-alkalmazás kulcsfontosságú komponense, amely ablakot biztosít a felhasználóval való interakcióhoz. Minden Activity egy külön képernyőt kezel: feladatlista, bejelentkezési űrlap, fotómegtekintés. Az Android rendszer az Activity-t kérésre hozza létre és megsemmisíti, amikor a memóriára más alkalmazásoknak van szüksége.

Az Activity először az Android 1.0-ban (2008) jelent meg és a felület fő építőköve maradt. A Google (2026) szerint a Google Play alkalmazásainak 98%-a tartalmaz legalább egy Activity-t. A modern architektúrában a Google egy Activity-t javasol több Fragment-tel, de a klasszikus többképernyős alkalmazás továbbra is elterjedt gyakorlat.

Activity stack (back stack) — a feladatverem, amely a navigációs előzményeket tárolja. Amikor a felhasználó megnyomja a „Vissza“ gombot, a jelenlegi Activity megsemmisül és az előző helyreáll. A rendszer automatikusan kezeli a vermet, de a fejlesztő szabályozhatja a viselkedést a launchMode és az Intent zászlók segítségével.

Activity életciklusa

Az Activity életciklusa — az állapotok és callback-ek halmaza, amelyen a képernyő áthalad a létrehozástól a megsemmisítésig. A Lifecycle megértése kritikus: az állapotokkal való helytelen munka memóriaszivárgáshoz, adatvesztéshez és az alkalmazás összeomlásához vezet.

Az Android rendszer szigorú sorrendben hívja meg a callback-eket. A fejlesztő felülírja a szükséges metódusokat az erőforrások inicializálásához, adatok mentéséhez és memória felszabadításához. Minden callback-hez tartozik egy pár: onCreate ↔ onDestroy, onStart ↔ onStop, onResume ↔ onPause.

Activity állapotai

Négy Activity állapotot különböztetünk meg: Running (onResume aktív), Paused (látható, de fókusz nélkül), Stopped (nem látható), Destroyed (megsemmisült). A rendszer megölheti az Activity-t Stopped állapotban memóriahiány esetén — az adatokat onSaveInstanceState-ben kell menteni.

Életciklus metódusai: onCreate, onStart, onResume

Vizsgáljuk meg az Activity életciklusának három kulcsmetódusát egy Kotlin példával. onCreate — belépési pont, egyszer hívódik meg. Itt történik a layout összekapcsolása setContentView-val, a RecyclerView inicializálása, a LiveData-ra való feliratkozás. onStart — az Activity láthatóvá válik a felhasználó számára. onResume — az Activity fókuszt kap és készen áll az interakcióra.

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

A példában az onCreate inicializálja a RecyclerView-t és betölti az adatokat. Az onStart elindítja a geolokációs frissítést — egy erőforrást, amelynek csak akkor kell működnie, ha a képernyő látható. Az onResume folytatja az onPause-ben leállított videót. Az ilyen szétválasztás megakadályozza a felesleges háttérmunkát.

Activity deklarálása AndroidManifest.xml-ben

Minden Activity-t deklarálni kell az AndroidManifest.xml fájlban. Regisztráció nélkül a rendszer nem találja a képernyőt és ActivityNotFoundException kivételt dob. A manifestben meg kell adni az osztály nevét, témát, tájolást, launchMode-ot és Intent szűrőket.

<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>

Az exported zászló határozza meg, hogy más alkalmazások indíthatják-e az Activity-t. A főképernyőhöz exported=true, belső képernyőkhöz — false. A parentActivityName attribútum bekapcsolja a szabványos „Fel“ navigációt (Up Navigation).

Activity indítása Intent segítségével

Intent — egy objektum, amely leírja a végrehajtandó műveletet. Az Activity kontextusában az Intent egy másik képernyő indítására szolgál adatátvitellel. Az Intent lehet explicit (egy konkrét osztályra mutat) és implicit (egy műveletre mutat, a rendszer kiválasztja a megfelelő komponenst).

// Explicit Intent — DetailActivity indítása adatokkal
val intent = Intent(this, DetailActivity::class.java).apply {
    putExtra("item_id", itemId)
    putExtra("item_name", itemName)
}
startActivity(intent)

// Adatok fogadása a DetailActivity-ben
val itemId = intent.getLongExtra("item_id", 0L)
val itemName = intent.getStringExtra("item_name") ?: ""

Az elindított Activity eredményének fogadásához az Activity Result API-t használjuk, amely felváltotta az elavult startActivityForResult-ot. Az új API típusbiztos, deklaratív és működik a Jetpack Compose-zal.

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

Állapot mentése újralétrehozáskor

Képernyőelforgatáskor vagy konfigurációváltáskor az Android újralétrehozza az Activity-t — egymás után meghívja az onDestroy-t és az onCreate-t. Állapotmentés nélkül a felhasználó elveszíti a bevitt adatokat, a görgetési pozíciót és a kiválasztott elemeket. A probléma megoldásához az Android két mechanizmust kínál: onSaveInstanceState és ViewModel.

Az onSaveInstanceState egyszerű adatokat ment el Bundle-be az onDestroy meghívása előtt. A Jetpack ViewModel-je ellenáll az Activity újralétrehozásának és memóriában tárolja az adatokat, ami hatékonyabb összetett objektumok és hálózati kérések esetén.

class MainActivity : AppCompatActivity() {

    private val viewModel: MainViewModel by viewModels()

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

        // A ViewModel automatikusan menti az adatokat
        viewModel.items.observe(this) { items ->
            updateAdapter(items)
        }
    }

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

Single Activity architektúra és Jetpack

A Google modern megközelítése — Single Activity architektúra egy Activity-vel és több Fragment-tel. Az alkalmazás egy MainActivity-t használ, a teljes navigációt pedig a Navigation Component végzi a NavHostFragment-en keresztül. Előnyök: centralizált navigáció, közös ViewModel képernyőnként, helyes működés Deep Links-szel.

A Jetpack Navigation Component automatizálja a back stack kezelését, az átmeneti animációkat és az argumentumok átvitelét. A NavHostFragment az Activity layout-jában helyezkedik el, a navigációs gráf (NavGraph) pedig leírja az összes képernyőt és a köztük lévő kapcsolatokat. Ezt a megközelítést a Google ajánlja új projektekhez, és megfelel a Material Design elveinek.

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)

        // NavigationUI konfigurálása AppBar számára
        setupActionBarWithNavController(navController)
    }

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