onResume — Conceitos básicos, interação com o usuário no Android

Conceitos básicos do método onResume no Android

onResume — o terceiro método do ciclo de vida de uma Activity, chamado após onStart, que sinaliza que a tela está pronta para interação total com o usuário. Neste momento, a Activity está no topo da pilha de tarefas (back stack), o sistema direciona todos os eventos de entrada para ela, e o aplicativo pode iniciar qualquer operação que exija participação ativa do usuário: chamadas de vídeo, jogos, gravação de áudio, desenho no Canvas.

onResume faz parte do “tempo de vida em primeiro plano” (foreground lifetime) — o intervalo entre onResume e onPause. Este é o período mais ativo de uma Activity, quando o aplicativo consome mais recursos: CPU para processar toques, GPU para renderizar animações, câmera e microfone para captura de vídeo. Entender este nível do ciclo de vida é fundamental para otimizar o consumo de energia — os recursos abertos em onResume devem ser fechados imediatamente em onPause.

De acordo com o Google I/O 2025, o tempo médio que uma Activity passa no estado onResume por sessão é de 2 a 5 minutos para aplicativos de notícias e de 15 a 30 minutos para jogos e mensageiros. Todo o resto do tempo, a Activity está nos estados onPause, onStop ou onDestroy. Isso significa que otimizar especificamente o código onResume proporciona os maiores ganhos em desempenho e duração da bateria.

onResume na Activity

Em uma Activity, o método onResume é chamado toda vez que a tela recebe o foco de entrada — ao iniciar pela primeira vez, ao retornar de outra Activity, ao fechar um diálogo, ao desbloquear o dispositivo. Este é um método “quente” que pode ser chamado muitas vezes por sessão, e sua implementação deve ser a mais leve possível.

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", "Failed to bind camera", e)
            }
        }, ContextCompact.getMainExecutor(this))
    }

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

O exemplo com CameraX demonstra o uso clássico de onResume/onPause: a câmera é um recurso exclusivo que apenas um aplicativo pode usar por vez. Vincular a câmera ao ciclo de vida através de bindToLifecycle fecha automaticamente a câmera em onPause, mas uma chamada explícita a unbindAll garante a liberação imediata. Isso é especialmente importante ao alternar entre Activities: a câmera deve ser liberada antes que outra Activity tente abri-la.

onResume no Fragment

onResume em um Fragment é chamado depois que a Activity que o contém recebeu onResume. No entanto, devido às particularidades do FragmentManager e ViewPager, o momento da chamada onResume para um Fragment pode ser atrasado em relação à Activity. Por exemplo, um Fragment em um ViewPager com offscreenPageLimit = 1 recebe onResume apenas quando se torna a página atual, não ao iniciar a 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()
    }
}

A verificação de userVisibleHint em Fragment.onResume é relevante para ViewPager: um Fragment pode receber onResume mas estar oculto por uma página vizinha (por exemplo, durante uma transição animada). Nesses casos, iniciar vídeo ou biometria em onResume sem verificar a visibilidade resultará em comportamento inesperado. A partir do Fragment 1.5.0, recomenda-se usar FragmentTransaction.setMaxLifecycle() para controle preciso do ciclo de vida dos fragmentos no ViewPager2.

onResume vs onStart: quando usar cada um

Os desenvolvedores frequentemente confundem onStart e onResume, colocando código no método errado. A regra principal: onStart — para recursos que funcionam enquanto visíveis; onResume — para recursos que exigem foco de entrada. Vamos ver cenários específicos e a escolha correta do método.

Uma regra prática: se uma operação deve ser interrompida quando um diálogo aparecer — use onResume/onPause. Se uma operação pode continuar quando a tela está parcialmente coberta — use onStart/onStop. Por exemplo, um player de vídeo deve pausar o vídeo ao abrir um diálogo (onPause), enquanto a geolocalização pode continuar atualizando (permanece em onStart).

Gerenciamento de recursos exclusivos

Recursos exclusivos são componentes do dispositivo que podem ser usados por apenas um aplicativo em um determinado momento. Câmera, microfone, saída de vídeo (MediaProjection), adaptador NFC em modo de leitura, dispositivos USB em modo accessory — todos esses recursos devem ser abertos em onResume e liberados em onPause.

Trabalhando com MediaRecorder

MediaRecorder é usado para gravar áudio e vídeo. Solicitações de permissão e preparação do MediaRecorder são feitas em onCreate, enquanto a gravação começa em onResume. Se o usuário mudar para outro aplicativo, onPause pausa a gravação e onResume a retoma. Este é o comportamento padrão para gravadores de voz e aplicativos de gravação de vídeo.

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

A autenticação biométrica (BiometricPrompt) deve ser chamada apenas quando a Activity está em onResume. Se chamada em onCreate ou onStart, o diálogo de biometria pode aparecer antes que a Activity termine a inicialização, levando a um processamento incorreto do resultado. Chamá-la em onResume garante que a janela de biometria seja exibida no contexto correto.

Padrões e recomendações

Vamos ver três padrões comprovados para trabalhar com onResume usados em projetos comerciais: reinício do temporizador de inatividade, atualização de dados visíveis e integração com Jetpack Navigation.

Reinício do temporizador de inatividade

Em aplicativos com dados confidenciais (bancos, registros médicos), onResume é usado para reiniciar o temporizador de logout automático. Se o usuário estiver interagindo ativamente com o aplicativo, onResume é chamado em cada transição de tela e o temporizador é reiniciado. Se o usuário minimizar o aplicativo, onPause para o temporizador, e onResume ao retornar ou o reinicia ou solicita nova autenticação.

Atualização de dados ao retornar

Uma lista que deve exibir dados atualizados toda vez que a tela for revisitada é atualizada em onResume. Por exemplo, se o usuário criou uma nova entrada em outra Activity e navegou de volta, onResume recarrega a lista do banco de dados local ou do cache da ViewModel. Isso garante consistência dos dados sem chamadas manuais a notifyDataSetChanged.

override fun onResume() {
    super.onResume()
    // ActivityResultLauncher retornou um resultado — atualizando a lista
    viewModel.refreshList()
    // Reinício do temporizador de inatividade
    inactivityTimer.reset()
}

Jetpack Navigation e onResume

No Jetpack Navigation, onResume de um fragment é chamado toda vez que você retorna a ele através da navegação reversa. Esta propriedade é usada para reiniciar o estado da UI: ocultar o teclado, limpar campos de pesquisa, atualizar o título da barra de ferramentas. OnBackPressedCallback combinado com onResume dá controle total sobre a navegação sem duplicação de código.