onResume — grunder, interaktion med användaren i Android

Grunderna i onResume-metoden i Android

onResume — den tredje metoden i Activitys livscykel, anropad efter onStart, som signalerar att skärmen är redo för full interaktion med användaren. I detta ögonblick befinner sig Activity överst i uppgiftsstacken (back stack), systemet dirigerar alla inmatningshändelser till den och applikationen kan starta alla operationer som kräver aktiv användarmedverkan: videosamtal, spel, ljudinspelning, ritning på Canvas.

onResume ingår i förgrundslivstiden (foreground lifetime) — perioden mellan onResume och onPause. Detta är den mest aktiva arbetsperioden för Activity, när applikationen förbrukar maximala resurser: processorn för att hantera beröringar, GPU för att rendera animationer, kameran och mikrofonen för videoinspelning. Att förstå denna nivå av livscykeln är avgörande för att optimera energiförbrukningen — resurser som öppnas i onResume måste omedelbart stängas i onPause.

Enligt Google I/O 2025 är den genomsnittliga tiden som Activity tillbringar i onResume-tillstånd per session 2–5 minuter för nyhetsappar och 15–30 minuter för spel och meddelandeappar. Resten av tiden befinner sig Activity i tillstånden onPause, onStop eller onDestroy. Detta innebär att optimering av just onResume-koden ger den största vinsten i prestanda och batteritid.

onResume i Activity

I Activity anropas onResume-metoden varje gång skärmen får inmatningsfokus — vid första start, vid återkomst från en annan Activity, vid stängning av en dialogruta, vid upplåsning av enheten. Detta är en het metod som kan anropas många gånger under en session och dess implementering bör vara så lätt som möjligt.

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", "Det gick inte att binda kameran", e)
            }
        }, ContextCompact.getMainExecutor(this))
    }

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

Exemplet med CameraX demonstrerar klassisk användning av onResume/onPause: kameran är en exklusiv resurs som endast kan användas av en applikation åt gången. Att binda kameran till livscykeln via bindToLifecycle stänger automatiskt kameran i onPause, men ett explicit anrop till unbindAll garanterar omedelbar frigörelse. Detta är särskilt viktigt vid växling mellan Activity: kameran måste frigöras innan en annan Activity försöker öppna den.

onResume i Fragment

onResume i Fragment anropas efter att Activity som innehåller det har fått onResume. På grund av FragmentManagers och ViewPagers särdrag kan dock anropstidpunkten för onResume för Fragment försenas i förhållande till Activity. Till exempel, ett Fragment i ViewPager med offscreenPageLimit = 1 får onResume först när det blir den aktuella sidan, inte vid start av Activity.

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

Kontroll av userVisibleHint i Fragment.onResume är relevant för ViewPager: Fragment kan få onResume men vara dolt av en angränsande sida (till exempel vid en animerad övergång). I sådana fall leder start av video eller biometri i onResume utan synlighetskontroll till oväntat beteende. Från Fragment 1.5.0 rekommenderas att använda FragmentTransaction.setMaxLifecycle() för exakt kontroll av fragmentens livscykel i ViewPager2.

onResume vs onStart: när ska man använda vad

Utvecklare blandar ofta ihop onStart och onResume och placerar kod i fel metod. Huvudregel: onStart — för resurser som fungerar vid synlighet; onResume — för resurser som kräver inmatningsfokus. Låt oss titta på specifika scenarier och korrekt val av metod.

Praktisk regel: om operationen ska avbrytas när en dialogruta visas — använd onResume/onPause. Om operationen kan fortsätta vid partiell täckning av skärmen — använd onStart/onStop. Till exempel måste en videospelare pausa videon när en dialog öppnas (onPause), medan geolokalisering kan fortsätta att uppdateras (stannar i onStart).

Hantering av exklusiva resurser

Exklusiva resurser är enhetskomponenter som endast kan användas av en applikation vid en given tidpunkt. Kamera, mikrofon, videoutgång (MediaProjection), NFC-adapter i läsläge, USB-enheter i accessory-läge — alla dessa resurser måste öppnas i onResume och frigöras i onPause.

Arbeta med MediaRecorder

MediaRecorder används för inspelning av ljud och video. Begäran om tillstånd och förberedelse av MediaRecorder görs i onCreate, och start av inspelning i onResume. Om användaren växlar till en annan applikation pausar onPause inspelningen och onResume återupptar den. Detta är standardbeteende för diktafoner och videoinspelningsapplikationer.

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

Biometrisk autentisering (BiometricPrompt) bör endast anropas när Activity är i onResume. Om du anropar det i onCreate eller onStart kan den biometriska dialogen visas innan Activity har slutfört initieringen, vilket leder till felaktig bearbetning av resultatet. Anrop i onResume garanterar att det biometriska fönstret visas i rätt sammanhang.

Mönster och rekommendationer

Låt oss titta på tre beprövade mönster för arbete med onResume som tillämpas i kommersiella projekt: återställning av inaktivitetstimer, uppdatering av synliga data och integration med Jetpack Navigation.

Återställning av inaktivitetstimer

I applikationer med konfidentiella data (bank, medicinska kort) används onResume för att återställa timern för automatisk utloggning. Om användaren aktivt interagerar med applikationen anropas onResume vid varje övergång mellan skärmar och timern återställs. Om användaren minimerar applikationen stoppar onPause timern och onResume vid återkomst antingen återställer den eller begär omautentisering.

Uppdatering av data vid återkomst

Listan som ska visa aktuell data vid varje återkomst till skärmen uppdateras i onResume. Till exempel, om användaren har skapat en ny post i en annan Activity och kommit tillbaka, laddar onResume om listan från den lokala databasen eller från ViewModel-cachen. Detta säkerställer datakonsistens utan manuellt anrop av notifyDataSetChanged.

override fun onResume() {
    super.onResume()
    // ActivityResultLauncher returnerade resultat — uppdaterar listan
    viewModel.refreshList()
    // Återställning av inaktivitetstimer
    inactivityTimer.reset()
}

Jetpack Navigation och onResume

I Jetpack Navigation anropas onResume för ett fragment vid varje återkomst till det via bakåtnavigering. Denna egenskap används för att återställa UI-tillståndet: dölja tangentbordet, rensa sökfält, uppdatera verktygsfältets titel. OnBackPressedCallback i kombination med onResume ger full kontroll över navigeringen utan kodduplicering.