onResume — alapok, felhasználói interakció Androidban

Az onResume metódus alapjai Androidban

Az onResume — az Activity életciklus harmadik metódusa, amely az onStart után hívódik meg, jelezve a képernyő teljes felhasználói interakcióra való felkészültségét. Ebben a pillanatban az Activity a feladatverem (back stack) tetején található, a rendszer az összes bemeneti eseményt hozzá irányítja, és az alkalmazás bármilyen, aktív felhasználói részvételt igénylő műveletet megkezdhet: videohívások, játékok, hangfelvétel, rajzolás Canvas-ra.

Az onResume az előtérbeli élettartam (foreground lifetime) része — az onResume és onPause közötti időszak. Ez az Activity legaktívabb munkavégzési időszaka, amikor az alkalmazás maximális erőforrásokat fogyaszt: a processzort az érintések feldolgozásához, a GPU-t az animációk megjelenítéséhez, a kamerát és a mikrofont a videórögzítéshez. Az életciklus ezen szintjének megértése kritikus fontosságú az energiafogyasztás optimalizálásához — az onResume-ben megnyitott erőforrásokat azonnal be kell zárni az onPause-ben.

A Google I/O 2025 adatai szerint az Activity által egy munkamenet során onResume állapotban töltött átlagos idő 2–5 perc a híralkalmazásoknál és 15–30 perc a játékoknál és üzenetküldőknél. Az idő többi részében az Activity onPause, onStop vagy onDestroy állapotban van. Ez azt jelenti, hogy éppen az onResume kód optimalizálása adja a legnagyobb teljesítmény- és akkumulátor-élettartam-növekedést.

onResume Activity-ben

Activity-ben az onResume metódus minden alkalommal meghívódik, amikor a képernyő bemeneti fókuszt kap — első indításkor, másik Activity-ből való visszatéréskor, párbeszédablak bezárásakor, az eszköz feloldásakor. Ez egy forró metódus, amely egy munkamenet során többször is meghívódhat, és megvalósításának a lehető legkönnyebbnek kell lennie.

class CameraActivity : AppCompatActivity() {
    private var cameraProvider: ProcessCameraProvider? = null
    private var preview: Preview? = null

    override fun onResume() {
        super.onResume()
        val cameraProviderFuture = ProcessCameraProvider.getInstance(this)
        cameraProviderFuture.addListener({
            cameraProvider = cameraProviderFuture.get()
            val cameraSelector = CameraSelector.DEFAULT_BACK_CAMERA
            preview = Preview.Builder().build().also {
                it.setSurfaceProvider(binding?.viewFinder?.surfaceProvider)
            }
            try {
                cameraProvider?.unbindAll()
                cameraProvider?.bindToLifecycle(
                    this, cameraSelector, preview
                )
            } catch (e: Exception) {
                Log.e("Camera", "Nem sikerült a kamerát kötni", e)
            }
        }, ContextCompact.getMainExecutor(this))
    }

    override fun onPause() {
        super.onPause()
        cameraProvider?.unbindAll()
        preview = null
    }
}

A CameraX példa az onResume/onPause klasszikus használatát mutatja: a kamera egy kizárólagos erőforrás, amelyet egyszerre csak egy alkalmazás használhat. A kamera életciklushoz kötése a bindToLifecycle segítségével automatikusan bezárja a kamerát onPause-ben, de az explicit unbindAll hívás garantálja az azonnali felszabadítást. Ez különösen fontos az Activity-k közötti váltáskor: a kamerát fel kell szabadítani, mielőtt egy másik Activity megpróbálná megnyitni.

onResume Fragment-ben

Az onResume Fragment-ben azután hívódik meg, hogy a tartalmazó Activity megkapta az onResume-t. A FragmentManager és ViewPager sajátosságai miatt azonban az onResume meghívásának pillanata a Fragment esetében késhet az Activity-hez képest. Például egy ViewPager-ben lévő Fragment offscreenPageLimit = 1 beállítással csak akkor kap onResume-t, amikor az aktuális oldallá válik, nem az Activity indításakor.

class VideoPlayerFragment : Fragment() {
    private var exoPlayer: ExoPlayer? = null

    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)
        exoPlayer = ExoPlayer.Builder(requireContext()).build()
        binding?.playerView?.player = exoPlayer
    }

    override fun onResume() {
        super.onResume()
        exoPlayer?.play()
        if (userVisibleHint) {
            startBiometricAuth()
        }
    }

    override fun onPause() {
        exoPlayer?.pause()
        stopBiometricAuth()
        super.onPause()
    }
}

A userVisibleHint ellenőrzése a Fragment.onResume-ben releváns a ViewPager esetében: a Fragment megkaphatja az onResume-t, de elrejtheti a szomszédos oldal (például animált átmenet során). Ilyen esetekben a videó vagy biometria elindítása az onResume-ben a láthatóság ellenőrzése nélkül váratlan viselkedéshez vezet. A Fragment 1.5.0-tól kezdve ajánlott a FragmentTransaction.setMaxLifecycle() használata a fragmentumok életciklusának pontos szabályozásához ViewPager2-ben.

onResume vs onStart: mikor mit használjunk

A fejlesztők gyakran összekeverik az onStart és onResume metódusokat, és rossz metódusba helyezik a kódot. Fő szabály: onStart — a láthatóságkor működő erőforrásokhoz; onResume — a bemeneti fókuszt igénylő erőforrásokhoz. Vizsgáljuk meg a konkrét forgatókönyveket és a metódus helyes kiválasztását.

Gyakorlati szabály: ha a műveletet meg kell szakítani egy párbeszédablak megjelenésekor — használja az onResume/onPause-t. Ha a művelet folytatódhat a képernyő részleges elfedésekor — használja az onStart/onStop-ot. Például a videolejátszónak szüneteltetnie kell a videót párbeszédablak megnyitásakor (onPause), míg a geolokáció folytathatja a frissítést (az onStart-ban marad).

Kizárólagos erőforrások kezelése

A kizárólagos erőforrások olyan eszközösszetevők, amelyeket egy adott pillanatban csak egy alkalmazás használhat. Kamera, mikrofon, videokimenet (MediaProjection), NFC-adapter olvasási módban, USB-eszközök accessory módban — mindezeket az erőforrásokat az onResume-ben kell megnyitni és az onPause-ben felszabadítani.

Munka a MediaRecorder-rel

A MediaRecorder audio és video rögzítésére szolgál. Az engedélyek kérése és a MediaRecorder előkészítése az onCreate-ben történik, a felvétel indítása pedig az onResume-ben. Ha a felhasználó másik alkalmazásra vált, az onPause szünetelteti a felvételt, az onResume pedig folytatja. Ez a szokásos viselkedés a dictafonok és videórögzítő alkalmazások esetében.

private var mediaRecorder: MediaRecorder? = null
private var isRecording = false

override fun onResume() {
    super.onResume()
    if (isRecording) {
        mediaRecorder?.resume()
    }
}

override fun onPause() {
    if (isRecording) {
        mediaRecorder?.pause()
    }
    super.onPause()
}

BiometricPrompt és onResume

A biometrikus hitelesítést (BiometricPrompt) csak akkor szabad meghívni, amikor az Activity onResume állapotban van. Ha az onCreate-ben vagy onStart-ban hívja meg, a biometrikus párbeszédablak megjelenhet, mielőtt az Activity befejezi az inicializálást, ami az eredmény helytelen feldolgozásához vezet. Az onResume-ben történő meghívás garantálja, hogy a biometrikus ablak a megfelelő kontextusban jelenjen meg.

Minták és ajánlások

Vizsgáljuk meg az onResume-mel való munka három bevált mintáját, amelyeket kereskedelmi projektekben alkalmaznak: az inaktivitási időzítő visszaállítása, a látható adatok frissítése és a Jetpack Navigation integráció.

Inaktivitási időzítő visszaállítása

A bizalmas adatokat kezelő alkalmazásokban (banki, orvosi kártyák) az onResume-t használják az automatikus kilépési időzítő visszaállítására. Ha a felhasználó aktívan interakcióba lép az alkalmazással, az onResume minden képernyőváltáskor meghívódik, és az időzítő visszaáll. Ha a felhasználó minimalizálja az alkalmazást, az onPause leállítja az időzítőt, és az onResume visszatéréskor vagy visszaállítja azt, vagy újrahitelesítést kér.

Adatok frissítése visszatéréskor

A listát, amelynek minden képernyőre való visszatéréskor aktuális adatokat kell mutatnia, az onResume-ben frissítik. Például, ha a felhasználó új rekordot hozott létre egy másik Activity-ben és visszatért, az onResume újratölti a listát a helyi adatbázisból vagy a ViewModel gyorsítótárból. Ez biztosítja az adatok konzisztenciáját a notifyDataSetChanged manuális meghívása nélkül.

override fun onResume() {
    super.onResume()
    // Az ActivityResultLauncher visszaadta az eredményt — lista frissítése
    viewModel.refreshList()
    // Inaktivitási időzítő visszaállítása
    inactivityTimer.reset()
}

Jetpack Navigation és onResume

A Jetpack Navigation-ban a fragmentum onResume-je minden, hozzá történő visszatéréskor meghívódik a visszafelé navigáció során. Ezt a tulajdonságot használják a UI állapotának visszaállítására: billentyűzet elrejtése, keresőmezők törlése, eszköztár címének frissítése. Az OnBackPressedCallback az onResume-mel kombinálva teljes irányítást biztosít a navigáció felett kódduplikáció nélkül.