Activity Lifecycle: por que você deve conhecer sobre o ciclo de vida da Activity

Resumindo

Nesse artigo, vamos conhecer mais sobre um recurso oferecido pela API da Activity no Android conhecido como ciclo de vida e entender um pouco mais sobre como ele funciona. Veremos também sobre:

Estados do ciclo de vida da Activity;
Como visualizar as etapas do ciclo de vida com o Logcat;
Ciclos de vida da Activity na prática com um projeto Android.

Depois de ler esse artigo, você vai entender melhor como funcionam os ciclos de vida de uma Activity e poderá fazer a configuração de comportamentos, gerenciamento de dados na tela, entre outras coisas, sabendo exatamente em qual etapa devem estar. Vamos nessa?

Ciclo de vida das Activities

Quando começamos a aprender sobre desenvolvimento de apps mobile no Android, uma das primeiras coisas que ouvimos falar é na Activity. Trata-se de um componente do Android que representa a tela do nosso aplicativo, onde vamos incluir os itens visuais para interação da pessoa usuária, como, por exemplo, textos, botões, menus de seleção, entre outros.

No exemplo abaixo, temos a tela principal de um aplicativo de lista de produtos, o Orgs. Essa tela é apresentada pela Activity principal, que tem os itens visuais, como as informações dos produtos, e itens de interação com a pessoa usuária, como o botão para acessar o formulário de cadastro de produto na parte inferior direita da tela:

Na imagem há uma um print de uma tela do aplicativo Orgs. Na parte superior do app, há uma barra na cor verde em que se lê o título “Orgs”. A seguir, há uma lista com dois itens chamados de “cesta de frutas” e “melancias”. Abaixo de “cesta de frutas”, podemos ler os dizeres “laranja, banana e maçã''. Abaixo do item “melancias”, consta o dizer “melancias maduras”. No canto inferior direito da tela do app, há um botão de cor verde em formato circular que contém um ícone de soma.

É preciso que o aplicativo tenha pelo menos uma Activity, que representa o ponto inicial e a primeira tela a ser exibida à pessoa usuária, chamada geralmente de MainActivity. Você pode se perguntar: um aplicativo pode ter mais de uma Activity? A resposta é sim, depende das necessidades do projeto em questão.

Bom, já sabemos que uma Activity permite representar uma tela do App, mas existem algumas regras que precisamos conhecer para conseguir configurar comportamentos desejados, como criar o layout, adicionar, atualizar ou remover dados da tela. E é sobre isso que veremos a seguir.

Estados do ciclo de vida da Activity

As Activities no Android contam com métodos de callback que vão permitir que as Activities transitem por diferentes estados do ciclo de vida à medida que a pessoa usuária navega no aplicativo.

O ciclo de vida de uma Activity é considerado desde o momento em que ela é criada até o momento em que é finalizada, e nesse período ela pode passar por diversas fases de acordo com a necessidade e complexidade do nosso aplicativo. Ou seja, o ciclo de vida de uma Activity está ligado a um processo que “nasce” (é iniciada), dura por um tempo (é executada) e depois “morre” (é finalizada).

Representação em forma de diagrama do fluxo do ciclo de vida de uma activity, em que temos, no centro verticalmente alinhados, os seis principais estados do ciclo. A coluna começa com a iniciação da Activity em que são chamados os métodos onCreate(), onStart() e OnResume(). Em seguida, está a indicação de que a Activity está rodando e os estados de onPause(), que puxa uma seta à direita para o onResume(), indicando que, se o usuário voltar para a Activity, este será o caminho do ciclo. Por sua vez, o estado de onStop() puxa uma seta para a direita, referenciando o método onResume() que, por sua vez, indica o onStart(), reiniciando o ciclo. No final da coluna, temos o método onDestroy() seguido da indicação de que a Activity foi fechada.

Fonte da imagem: Kotlin com Android, editora Casa do Código

Neste diagrama, vemos que a Activity possui sete principais estados:

onCreate();
onStart();
onResume();
onPause();
onStop();
onRestart() e;
onDestroy().

Cada um deles tem seu momento de execução e função dentro do nosso aplicativo, que vamos conhecer melhor a seguir.

onCreate()

O onCreate() é o primeiro método de callback, responsável pela criação da Activity e é executado uma só vez, até a Activity ser destruída. É nessa etapa que são realizadas as configurações estáticas que podem ou precisam ser executadas uma única vez, por exemplo, a criação de layouts e vínculo de dados à listas.

Aqui, vale ressaltar que a Activity não fica no estado de criação. Logo após o método onCreate() concluir sua execução, o sistema chama o método onStart() e passa para o estado de iniciado, em que efetivamente aparecerá para a pessoa usuária.

onStart()

Esse callback é invocado quando a Activity sai do estado de interrompida (onStop()) e volta a ser utilizada.

Esse método é executado rapidamente e, finalizada essa etapa, a Activity passa para o próximo estado, em que estará pronta para realizar os processos de interação com quem vai utilizar o aplicativo.

onResume()

Em seguida, o método onResume() é o que efetivamente deixa o aplicativo pronto para uso, permitindo interação com as pessoas usuárias. É nesse estado, chamado de em retomada, que o aplicativo também consegue ativar qualquer funcionalidade que precise operar enquanto estiver sendo utilizado, por exemplo, a inicialização da câmera.

Nesse estado, a Activity fica na parte superior da pilha de navegação e captura toda interação que a pessoa usuária faz. O aplicativo ficará nesse estado até acontecer uma ação que saia da tela, como acessar outra Activity ou fechar o app.

Ou seja, quando a pessoa está utilizando o aplicativo em primeiro plano, temos o estado onResume(). Mas, e se a pessoa receber uma ligação telefônica que sobrepõe o app atual?

onPause()

Quando acontece uma mudança de foco de atenção, ou seja, quando ocorre alguma sobreposição ao aplicativo atual, como, receber uma ligação, por exemplo, a Activity entra em estado de pausada.

Esse estado é um primeiro indicador de que a Activity não está 100% em foco para a pessoa usuária. Porém, o aplicativo ainda não foi fechado, e pode ser visualizado no modo de exibição de múltiplas janelas, por exemplo.

No modo de múltiplas janelas, vale ressaltar que o comportamento da etapa do ciclo de vida pode ser diferente de acordo com a versão do Android utilizada. No Android 9 e versões anteriores, no modo múltiplas janelas, a Activity entra em estado de onPause() quando a outra janela está focada e volta para onResume() quando o foco retorna para ela. Já no Android 10 e versões mais recentes, a Activity permanece no estado onResume() enquanto é utilizada no modo de múltiplas janelas. Para saber mais sobre as particularidades do ciclo de vida relacionadas ao modo de múltiplas janelas, você pode dar uma olhada na documentação.

Durante o estado de pausa, a Activity pode seguir para dois próximos estados possíveis: ou onStop(), caso fique totalmente invisível para a pessoa usuária, ou onResume(), caso volte ao foco.

onStop()

Quando a Activity fica completamente invisível para a pessoa usuária, o sistema chama o callback onStop() e passará ao estado interrompido.

Nesse estado, o aplicativo irá liberar ou ajustar mais recursos que não precisam estar disponíveis enquanto a Activity não estiver visível para a pessoa usuária, por exemplo, pausar animações e exibir itens menos detalhados.

Porém, onStop permite ainda a visualização do aplicativo no modo de múltiplas janelas.

onRestart()

Esse callback é invocado quando a Activity sai do estado de pausado (onPause()) ou de interrompido (onStop()) e volta a ser utilizada. O onRestart() sinaliza que a Activity está sendo iniciada novamente e restaura seu estado a partir do momento que foi interrompida.

O método onRestart() é sempre seguido do onStart(), iniciando novamente o ciclo.

onDestroy()

O método onDestroy() é chamado quando a Activity será destruída e isso pode acontecer devido ao fato de a pessoa usuária descartar completamente o aplicativo, ou então quando ocorre alguma mudança de configuração como a rotação da tela.

Se o aplicativo for fechado, o onDestroy() será o callback final do ciclo de vida.

Porém, caso tenha sido chamado devido a uma mudança de configuração do sistema, criará automaticamente uma nova instância da Activity e chamará o método onCreate() para essa nova configuração.

Ciclos de vida na prática

Acabamos de conhecer mais a fundo sobre cada estado do ciclo de vida das Activities. E agora, como visualizar isso na prática?

Essas alterações das etapas do ciclo de vida acontecem por trás do funcionamento do nosso aplicativo e por isso não vemos elas acontecendo normalmente. Porém, podemos utilizar um recurso muito bacana do Android Studio que são os Logs.

Através deles, podemos exibir mensagens em tempo real a respeito do funcionamento do nosso aplicativo e visualizá-las por meio da janela Logcat.

Print de uma parte da tela do Android Studio em que está aberta a janela Logcat e assinalada na barra de menu inferior. Ainda, constam alguns dados de logs escritos na janela.

Para utilizar essa ótima ferramenta, vamos utilizar o log de informação (Log.i()) e inseri-lo no código da Activity em cada um dos estados. O código final dessa parte da Activity ficaria assim:

const val TAG = "Estado da Activity"

class ListaProdutosActivity : AppCompatActivity() {

    // restante do código

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(binding.root)
        configuraRecyclerView()
        configuraFab()
        Log.i(TAG, "onCreate: ")
    }

    override fun onStart() {
        super.onStart()
        Log.i(TAG, "onStart: ")
    }

    override fun onResume() {
        super.onResume()
        adapter.atualiza(dao.buscaTodos())
        Log.i(TAG, "onResume: ")
    }

    override fun onPause() {
        super.onPause()
        Log.i(TAG, "onPause: ")
    }

    override fun onStop() {
        super.onStop()
        Log.i(TAG, "onStop: ")
    }

    override fun onRestart() {
        super.onRestart()
        Log.i(TAG, "onRestart: ")
    }

    override fun onDestroy() {
        super.onDestroy()
        Log.i(TAG, "onDestroy: ")
    }

Depois de fazer a inclusão dos códigos para exibir os Logs do aplicativo, vamos executar novamente e ver o que acontece quando abrimos o aplicativo:

Gif mostrando a tela do Android Studio dividida verticalmente quase ao meio. Do lado direito, temos o emulador representando um celular com o aplicativo Orgs rodando. Na parte esquerda, temos a janela do Logcat mostrando as mensagens de log de informação descritas a seguir que aparecem à medida que são feitas interações com o aplicativo.

Repare que o gif acima mostra as mensagens de informação que aparecem no Logcat. Essas mensagens informam o que queremos acompanhar, que é o ciclo de vida de uma Activity, e temos as seguintes situações:

Quando executamos o aplicativo pela primeira vez, são chamados os callbacks onCreate(), onStart() e onResume(), que, respectivamente, fazem a criação, exibição e liberação para interação da Activity;
Quando clicamos no botão de adicionar um novo produto, o aplicativo sai da Activity principal e vai para a Activity de cadastro de produto e, nesse momento, são chamados o onPause() e o onStop(), que indicam que a Activity ficou fora do plano principal de visualização e logo em seguida ficou totalmente invisível para a pessoa usuária;
Ao voltarmos para a Activity principal, é chamado o callback onRestart(), que é acionado quando a Activity está no estado de parada e é iniciada novamente, onde são acionados os callbacks de inicialização onStart() e onResume();
Verificamos, também, o comportamento quando há rotação da tela do aparelho. Nesse caso, o sistema chama o callback onDestroy() e destrói a Activity e, em seguida, cria automaticamente uma nova instância para esta nova configuração, chamando os callbacks onCreate(), onStart() e onResume();
Por fim, temos o fechamento completo do aplicativo, em que o sistema chama o onDestroy() e finaliza o ciclo daquela Activity.

Bacana ver os ciclos de vida funcionando na prática, não é? Então, agora, vou te fazer um convite pra colocar a mão na massa e ver isso tudo funcionando no aplicativo que você estiver criando.

Se preferir, pode utilizar o projeto do curso Android com Kotlin: Personalize o seu App, que foi o que utilizei como exemplo aqui nesse artigo,conferindo direto no repositório do GitHub.

Ah! Deixei o código completo da Activity com as inclusões de logs de informações que fizemos durante o artigo pra você conferir se tiver alguma dúvida quando for aplicar por aí.

Conclusão

Nesse artigo, conhecemos um pouco sobre o que são Activities no Android e como elas funcionam.

Vimos também o que é o ciclo de vida da Activity, quais são e como funcionam os métodos de callback que compõem esse ciclo.

E, por fim, ainda aprendemos a visualizar essas etapas do ciclo de vida através dos logs.

Curtiu conhecer mais sobre as Activities e quer se aprofundar mais no universo do Android? Então confira aqui o nosso curso inicial de Android com Kotlin.

E se você gostou desse conteúdo, compartilhe com as amigas e amigos que podem gostar também e marca a gente lá nas redes sociais. Até a próxima! =D