Introdução

Neste tutorial, você aprende sobre uma parte fundamental do Android: A atividade e o ciclo de vida do fragmento. O ciclo de vida da atividade é o conjunto de estados em que uma atividade pode estar durante seu tempo de vida. O ciclo de vida se estende desde quando a atividade é inicialmente criada até quando é destruída e o sistema recupera os recursos dessa atividade. À medida que um usuário navega entre as atividades em seu aplicativo (e dentro e fora de seu aplicativo), essas atividades fazem a transição entre diferentes estados no ciclo de vida da atividade.

O ciclo de vida do fragmento é muito semelhante ao das atividades. Este tutorial se concentra principalmente nas atividades, com uma rápida análise dos fragmentos no final.

Como desenvolvedor Android, você precisa entender o ciclo de vida da atividade. Se suas atividades não respondem corretamente às mudanças de estado do ciclo de vida, seu aplicativo pode gerar erros estranhos, comportamento confuso para seus usuários ou usar muitos recursos do sistema Android. Compreendendo o ciclo de vida do Android e responder corretamente às mudanças de estado do ciclo de vida é fundamental para ser um bom cidadão do Android.

O que já deveria saber

O que aprenderá

O que fará

Neste tutorial, você trabalha com um aplicativo inicial chamado DessertClicker. Nesse aplicativo, cada vez que o usuário toca uma sobremesa na tela, o aplicativo "compra" a sobremesa para o usuário. O aplicativo atualiza os valores no layout para o número de sobremesas que foram compradas e para o valor total gasto pelo usuário.

Este aplicativo contém vários erros relacionados ao ciclo de vida do Android: Por exemplo, em certas circunstâncias, o aplicativo redefine os valores de sobremesa para 0 e continua usando recursos do sistema mesmo quando está em segundo plano. Compreendendo o ciclo de vida do Android ajudará você a entender por que esses problemas acontecem e como corrigi-los.

Cada atividade e cada fragmento tem o que é conhecido como um ciclo de vida. Esta é uma alusão aos ciclos de vida dos animais, como o ciclo de vida desta borboleta - os diferentes estados da borboleta mostram seu crescimento desde o nascimento até a idade adulta formada e até a morte.

Da mesma forma, o ciclo de vida da atividade é formado pelos diferentes estados pelos quais uma atividade pode passar, desde o momento em que a atividade é inicializada pela primeira vez até quando é finalmente destruída e sua memória recuperada pelo sistema. Conforme o usuário inicia seu aplicativo, navega entre as atividades, navega dentro e fora do seu aplicativo e sai dele, a atividade muda de estado. O diagrama abaixo mostra todos os estados do ciclo de vida da atividade. Como seus nomes indicam, esses estados representam o status da atividade.

Frequentemente, você deseja alterar algum comportamento ou executar algum código quando o estado do ciclo de vida da atividade muda. Portanto, a própria classe Activity e quaisquer subclasses de Activity como AppCompatActivity implementam um conjunto de métodos de retorno de chamada do ciclo de vida. O Android invoca esses retornos de chamada quando a atividade muda de um estado para outro, e você pode substituir esses métodos em suas próprias atividades para realizar tarefas em resposta a essas mudanças de estado do ciclo de vida. O diagrama a seguir mostra os estados do ciclo de vida junto com os retornos de chamada substituíveis disponíveis.

Um fragmento também tem um ciclo de vida. O ciclo de vida de um fragmento é semelhante ao ciclo de vida de uma atividade, portanto, muito do que você aprende se aplica a ambos. Neste tutorial, você se concentra no ciclo de vida da atividade, pois é uma parte fundamental do Android e a mais fácil de observar em um aplicativo simples. Aqui está o diagrama correspondente para o ciclo de vida do fragmento:

É importante saber quando esses retornos de chamada são usados e o que fazer em cada método de retorno de chamada. Mas ambos os diagramas são complexos e podem ser confusos. Neste tutorial, em vez de apenas ler o que cada estado e retorno de chamada significa, você fará um trabalho de detetive e desenvolverá sua compreensão do que está acontecendo.

Etapa 1: Examine o método onCreate()e adicione registro

Para descobrir o que está acontecendo com o ciclo de vida do Android, é útil saber quando os vários métodos de ciclo de vida são chamados. Isso ajudará você a descobrir onde algo está dando errado no DessertClicker.

Uma maneira simples de fazer isso é usar a API de registro do Android. O registro permite que você escreva mensagens curtas em um console enquanto o aplicativo é executado e você pode usá-lo para mostrar quando diferentes retornos de chamada são acionados.

  1. Baixe o aplicativo inicial DessertClicker e abra-o no Android Studio.
  2. Compile e execute o aplicativo e toque várias vezes na imagem da sobremesa. Observe como o valor de Desserts Sold e o valor total em dólares mudam.
  3. Abra MainActivity.kt e examine o método onCreate() para esta atividade
override fun onCreate(savedInstanceState: Bundle?) {
...
}

No diagrama do ciclo de vida da atividade, você pode ter reconhecido o método onCreate(), pois já usou esse retorno de chamada antes. É o único método que toda atividade deve implementar. O método onCreate() é onde você deve fazer qualquer inicialização única para sua atividade. Por exemplo, em onCreate() você infla o layout, define ouvintes de clique ou configura a vinculação de dados.

O método de ciclo de vida onCreate() é chamado uma vez, logo após a atividade ser inicializada (quando o novo objeto Activity é criado na memória). Após a execução de onCreate(), a atividade é considerada criada.

  1. No método onCreate(), logo após a chamada para super.onCreate(), adicione a seguinte linha. Importe a classe Log se necessário. (Pressione Alt+Enter ou Option+Enter em um Mac e selecione Import).
Log.i("MainActivity", "onCreate Called")

A classe Log grava mensagens no Logcat. Existem três partes para este comando:

  1. Compile e execute o aplicativo DessertClicker. Você não vê nenhuma diferença de comportamento no aplicativo ao tocar na sobremesa. No Android Studio, na parte inferior da tela, clique na guia Logcat.



    O Logcat é o console para registrar mensagens. Mensagens do Android sobre o seu aplicativo aparecem aqui, incluindo as mensagens que você envia explicitamente para o registro com o método Log.i() ou outros métodos de classe Log.
  2. No painel Logcat, digite I/MainActivity no campo de pesquisa.


    O Logcat pode conter muitas mensagens, a maioria das quais não são úteis para você. Você pode filtrar as entradas do Logcat de várias maneiras, mas pesquisar é a mais fácil. Como você usou MainActivity como a etiqueta de registro em seu código, você pode usar essa etiqueta para filtrar o registro. Adicione I/ no início significa que esta é uma mensagem informativa, criada por Log.i().

    Sua mensagem de registro inclui a data e hora, o nome do pacote (com.example.android.dessertclicker), sua etiqueta de registro (com I/ no início) e a mensagem real. Como essa mensagem aparece no log, você sabe que onCreate() foi executado.

Etapa 2: Implemente o método onStart()

O método de ciclo de vida onStart() é chamado logo após onCreate(). Depois que onStart() for executado, sua atividade ficará visível na tela. Ao contrário de onCreate(), que é chamado apenas uma vez para inicializar sua atividade, onStart() pode ser chamado muitas vezes no ciclo de vida de sua atividade.

Observe que onStart() está emparelhado com um método de ciclo de vida onStop() correspondente. Se o usuário iniciar seu aplicativo e depois retornar à tela inicial do dispositivo, a atividade será interrompida e não estará mais visível na tela.

  1. No Android Studio, com MainActivity.kt aberto, selecione Code > Override Methods ou pressione Control+o. Uma caixa de diálogo aparecerá com uma lista enorme de todos os métodos que você pode substituir nesta classe.
  2. Comece inserindo onStart para pesquisar o método correto. Para rolar para o próximo item correspondente, use a seta para baixo. Escolha onStart() na lista e clique em OK para inserir o código de substituição padrão. O código é parecido com este:
override fun onStart() {
   super.onStart()
}
  1. Dentro do método onStart(), adicione uma mensagem de registro:
override fun onStart() {
   super.onStart()

   Log.i("MainActivity", "onStart Called")
}
  1. Compile e execute o aplicativo DessertClicker e abra o painel Logcat. Digite I/MainActivity no campo de pesquisa para filtrar o registro. Observe que os métodos onCreate() e onStart() foram chamados um após o outro e que sua atividade está visível na tela.
  2. Pressione o botão Início no dispositivo e, em seguida, use a tela Recentes para retornar à atividade. Observe que a atividade continua de onde parou, com os mesmos valores, e que onStart() é registrado uma segunda vez no Logcat. Observe também que o método onCreate() geralmente não é chamado novamente.

Nesta tarefa, você modifica seu aplicativo para usar uma biblioteca de registro popular chamada Timber. Timber tem várias vantagens sobre a classe Android Log embutida. Em particular, a biblioteca Timber:

Você verá o primeiro benefício imediatamente; os outros você apreciará ao criar e enviar aplicativos maiores.

Etapa 1: Adicione Timber ao Gradle

  1. Visite este enlace para o Projeto Timber no GitHub e copie a linha de código sob o título Download que começa com a palavra implementation. A linha de código será semelhante a isto, embora o número da versão possa ser diferente. 
implementation 'com.jakewharton.timber:timber:4.7.1'
  1. No Android Studio, na vista Project: Android, expanda Gradle Scripts e abra o arquivo build.gradle (Module: App).
  2. Dentro da seção de dependências, cole a linha de código que você copiou.
dependencies {
   ...
   implementation 'com.jakewharton.timber:timber:4.7.1'
}
  1. Clique no enlace Sync Now no canto superior direito do Android Studio para reconstruir o Gradle. A construção deve ser executada sem erros.

Etapa 2: Crie uma classe de aplicativo e inicializar o Timber

Nesta etapa, você cria uma classe Application. Application é uma classe base que contém o estado global do aplicativo para todo o seu aplicativo. É também o principal objeto que o sistema operacional usa para interagir com seu aplicativo. Há uma classe Application padrão que o Android usa se você não especificar uma, então sempre há um objeto Application criado para seu aplicativo, sem a necessidade de fazer nada especial para crie-o.

Timber usa a classe Application, pois todo o aplicativo usará esta biblioteca de registro e a biblioteca precisa ser inicializada uma vez, antes de tudo o mais ser configurado. Em casos como esse, você pode criar uma subclasse da classe Application e substituir os padrões com sua própria implementação personalizada.

Depois de criar sua classe Application, você precisa especificar a classe no manifesto Android.

  1. No pacote dessertclicker, crie uma classe Kotlin chamada ClickerApplication. Para fazer isso, expanda app > java e clique com o botão direito em com.example.android.dessertclicker. Selecione New > Kotlin File/Class.
  2. Nomeie a classe como ClickerApplication e defina o Kind como Class. Clique em OK.

O Android Studio cria uma classe ClickerApplication e a abre no editor de código. O código é parecido com este: 

package com.example.android.dessertclicker

class ClickerApplication {
}
  1. Mude a definição da classe para uma subclasse de Application e importe a classe Application se necessário.
class ClickerApplication : Application() {
  1. Para substituir o método onCreate(), selecione Code > Override Methods ou pressione Control+o. 
class ClickerApplication : Application() {
   override fun onCreate() {
       super.onCreate()
   }
}
  1. Dentro desse método onCreate(), inicialize a biblioteca Timber:
override fun onCreate() {
    super.onCreate()

    Timber.plant(Timber.DebugTree())
}

Esta linha de código inicializa a biblioteca Timber para seu aplicativo para que você possa usar a biblioteca em suas atividades.

  1. Abra AndroidManifest.xml.
  2. Na parte superior do elemento <application>, adicione um novo atributo para a classe ClickerApplication, para que o Android saiba usar sua classe Application do padrão.
<application
   android:name=".ClickerApplication"
...

Etapa 3: Adicione declarações de registro de Timber

Nesta etapa, você altera suas chamadas Log.i() para usar Timber e, em seguida, implementa o registro para todos os outros métodos de ciclo de vida.

  1. Abra MainActivity e role até onCreate(). Substitua Log.i() por Timber.i() e remova a etiqueta de registro.
Timber.i("onCreate called")

Como a classe Log, Timber também usa o método i() para mensagens informativas. Observe que com Timber você não precisa adicionar uma etiqueta de registro; Timber usa automaticamente o nome da classe como a etiqueta de registro.

  1. Da mesma forma, altere a chamada Log em onStart():
override fun onStart() {
   super.onStart()

   Timber.i("onStart Called")
}
  1. Compile e execute o aplicativo DessertClicker e abra o Logcat. Observe que você ainda vê as mesmas mensagens de registro para onCreate() e onStart(), somente que agora é Timber gerando essas mensagens, não Log.
  2. Substitua o restante dos métodos de ciclo de vida em sua MainActivity e adicione as instruções de registro Timber para cada um. Aqui está o código:
override fun onResume() {
   super.onResume()
   Timber.i("onResume Called")
}

override fun onPause() {
   super.onPause()
   Timber.i("onPause Called")
}

override fun onStop() {
   super.onStop()
   Timber.i("onStop Called")
}

override fun onDestroy() {
   super.onDestroy()
   Timber.i("onDestroy Called")
}

override fun onRestart() {
   super.onRestart()
   Timber.i("onRestart Called")
}
  1. Compile e execute o DessertClicker novamente e examine o Logcat. Desta vez, observe que além de onCreate() e onStart(), há uma mensagem de registro para o retorno de chamada do ciclo de vida de onResume().

Quando uma atividade começa do zero, você vê todos os três desses retornos de chamada do ciclo de vida chamados em ordem:

Apesar do nome, o método onResume() é chamado na inicialização, mesmo que não haja nada para retomar.

Agora que o aplicativo DessertClicker está configurado para registro, você está pronto para começar a usar o aplicativo de várias maneiras e para explorar como os retornos de chamada do ciclo de vida são acionados em resposta a esses usos.

Caso de uso 1: Abrindo e fechando a atividade

Você começa com o caso de uso mais básico, que é iniciar seu aplicativo pela primeira vez e, em seguida, fecha o aplicativo completamente.

  1. Compile e execute o aplicativo DessertClicker, se ainda não estiver em execução. Como você viu, os retornos de chamada onCreate(), onStart() e onResume() são chamados quando a atividade começa pela primeira vez.
  2. Toque no bolinho algumas vezes.
  3. Toque no botão Voltar no dispositivo. Observe no Logcat que onPause(), onStop() e onDestroy() são chamados, nessa ordem.

    Nesse caso, o uso do botão Voltar faz com que a atividade (e o aplicativo) sejam fechados. A execução do método onDestroy() significa que a atividade foi encerrada e pode ser coletada como lixo. Coleta de lixo refere-se à limpeza automática de objetos que você não usará mais. Depois que onDestroy() é chamado, o sistema operacional sabe que esses recursos são descartáveis ​​e começa a limpar a memória.

    Sua atividade também pode ser encerrada se seu o código chama manualmente o método finish() da atividade ou se o usuário forçar o encerramento do aplicativo. (Por exemplo, o usuário pode forçar o encerramento do aplicativo na tela recente clicando no X no canto da janela). O sistema Android também pode desligar sua atividade por conta própria se o seu aplicativo não aparece na tela há muito tempo. O Android faz isso para economizar bateria e permitir que os recursos do seu aplicativo sejam usados ​​por outros aplicativos.
  4. Use a tela Recentes para retornar ao aplicativo. Aqui está o Logcat:


    A atividade foi destruída na etapa anterior, então, quando você retorna ao aplicativo, o Android inicia uma nova atividade e chama os métodos onCreate(), onStart() e onResume(). Observe que nenhuma das estatísticas do DessertClicker da atividade anterior foi retida.

    O ponto-chave aqui é que onCreate() e onDestroy() são chamados apenas uma vez durante o tempo de vida de uma única instância de atividade: onCreate() para inicializar o aplicativo pela primeira vez e onDestroy() para limpar os recursos usados ​​por seu aplicativo.

    O onCreate() método é uma etapa importante; é para onde vai toda a sua primeira inicialização, onde você configura o layout pela primeira vez, inflando-o, e onde você inicializa suas variáveis.

Caso de uso 2: Navegando de volta para a atividade

Agora que você iniciou o aplicativo e o fechou completamente, viu a maioria dos estados do ciclo de vida para quando a atividade é criada pela primeira vez. Você também viu todos os estados de ciclo de vida pelos quais a atividade passa quando é desligada e destruída. Mas, à medida que os usuários interagem com seus dispositivos com Android, eles alternam entre aplicativos, voltam para casa, iniciam novos aplicativos e tratam com interrupções por outras atividades, como vinculações.

Sua atividade não fecha sempre que o usuário sai dessa atividade:

Quando seu aplicativo está em segundo plano, ele não deve estar em execução ativa para preservar os recursos do sistema e a vida útil da bateria. Você usa o ciclo de vida Activity e seus retornos de chamada para saber quando seu aplicativo está se movendo para o segundo plano, para que você possa pausar qualquer operação em andamento. Em seguida, você reinicia as operações quando seu aplicativo entra em primeiro plano.

Por exemplo, considere um aplicativo que executa uma simulação de física. São necessários muitos cálculos, processados ​​na CPU do seu dispositivo, para decidir onde todos os objetos em sua simulação devem estar e para exibi-los. Se um telefonema interromper a simulação, o usuário pode ficar confuso ou até chateado ao voltar ao aplicativo e ver que a simulação foi concluída.

Há também um motivo de desempenho para isso. Digamos que o usuário tenha aberto 20 aplicativos que usam simulações de física com uso intensivo de CPU. Se as atividades desses aplicativos não estiverem na tela, mas ainda estiverem fazendo cálculos pesados ​​de renderização em segundo plano, isso diminuirá o desempenho de todo o telefone.

Nesta etapa, você observa o ciclo de vida da atividade quando o aplicativo entra em segundo plano e retorna novamente ao primeiro plano.

  1. Com o aplicativo DessertClicker em execução, clique no bolinho algumas vezes.
  2. Pressione o botão Home no seu dispositivo e observe o Logcat no Android Studio. Retorne à tela inicial coloca seu aplicativo em segundo plano, em vez de encerrá-lo completamente. Observe que os métodos onPause() e onStop() são chamados, mas onDestroy() não.


    Quando onPause() é chamado, o aplicativo não tem mais o foco. Depois de onStop(), o aplicativo não está mais visível na tela. Embora a atividade tenha sido interrompida, o objeto Activity ainda está na memória, em segundo plano. A atividade não foi destruída. O usuário pode retornar ao aplicativo, então o Android mantém seus recursos de atividade por perto.
  3. Use a tela Recentes para retornar ao aplicativo. Observe no Logcat que a atividade é reiniciada com onRestart() e onStart() e então retomada com onResume().


    Quando a atividade retorna ao primeiro plano, o método onCreate() não é chamado novamente. O objeto de atividade não foi destruído, portanto, não precisa ser criado novamente. Em vez de onCreate(), o método onRestart() é chamado. Observe que, desta vez, quando a atividade retorna ao primeiro plano, o número de Desserts Sold é mantido.
  4. Inicie, pelo menos, um aplicativo diferente do DessertClicker para que o dispositivo tenha alguns aplicativos em sua tela recente.
  5. Abra a tela Recentes e abra outra atividade recente. Em seguida, volte aos aplicativos recentes e traga o DessertClicker de volta ao primeiro plano.

    Observe que você vê os mesmos retornos de chamada no Logcat aqui como quando você pressionou o botão Home. onPause() e onStop() são chamados quando o aplicativo entra em segundo plano e, em seguida, onRestart(), onStart() e onResume() quando ele voltar.

    O ponto importante aqui é que onStart() e onStop() são chamados várias vezes enquanto o usuário navega de e para a atividade. Você deve substituir esses métodos para interromper o aplicativo quando ele for movido para o segundo plano ou iniciá-lo novamente quando ele retornar ao primeiro plano.

    E quanto a onRestart()? O método onRestart() é muito parecido com onCreate(). onCreate() ou onRestart() é chamado antes que a atividade se torne visível. O método onCreate() é chamado apenas na primeira vez, e onRestart() é chamado depois disso. O método onRestart() é um local para colocar o código que você somente deseja chamar se sua atividade not for iniciada pela primeira vez.

Caso de uso 3: Ocultando parcialmente a atividade

Você aprendeu que quando um aplicativo é iniciado e onStart() é chamado, o aplicativo se torna visível na tela. Quando o aplicativo é reiniciado e onResume() é chamado, o aplicativo ganha o foco do usuário. A parte do ciclo de vida em que o aplicativo está na tela e tem o foco do usuário é chamada de ciclo de vida interativo.

Quando o aplicativo vai para o segundo plano, o foco é perdido após onPause() e o aplicativo não fica mais visível após onStop().

A diferença entre foco e visibilidade é importante, pois é possível que uma atividade seja parcialmente visível na tela, mas não tenha o foco do usuário. Nesta etapa, você vê um caso em que uma atividade é parcialmente visível, mas não tem o foco do usuário.

  1. Com o aplicativo DessertClicker em execução, clique no botão Share no canto superior direito da tela.




    A atividade de compartilhamento aparece na metade inferior da tela, mas a atividade ainda é visível na metade superior.
  2. Examine o Logcat e observe que apenas onPause() foi chamado.


    Neste caso de uso, onStop() não é chamado, pois a atividade ainda está parcialmente visível. Mas a atividade não tem foco no usuário, e o usuário não pode interagir com ela. A atividade de "compartilhamento" que está em primeiro plano tem o foco do usuário.

    Por que essa diferença é importante? Considere o aplicativo de física. Você pode querer que a simulação pare quando o aplicativo estiver em segundo plano e continue em execução quando o aplicativo estiver parcialmente obscurecido. Neste caso, você interromperia a simulação em onStop(). Se você quiser que a simulação pare quando a atividade estiver parcialmente obscurecida, você deve colocar o código para parar a simulação em onPause().

    Qualquer código executado em onPause() bloqueia a exibição de outros, portanto, mantenha o código onPause() leve. Por exemplo, se uma chamada telefônica for recebida, o código em onPause() pode atrasar a notificação da chamada recebida.
  3. Clique fora da caixa de diálogo de compartilhamento para retornar ao aplicativo e observe que onResume() é chamado.

    Ambos onResume() e onPause() tem a ver com foco. O método onResume() é chamado quando a atividade tem foco, e onPause() é chamado quando a atividade perde o foco.

O ciclo de vida do fragmento do Android é semelhante ao ciclo de vida da atividade, além de vários métodos específicos do fragmento.

Nesta tarefa, você examina o aplicativo AndroidTrivia que construiu nos tutoriais anteriores e adiciona algum registro para explorar o ciclo de vida do fragmento. O aplicativo AndroidTrivia permite responder a perguntas sobre o desenvolvimento do Android; se você responder três em uma linha corretamente, você ganha o jogo.

Cada tela no aplicativo AndroidTrivia é um Fragment.

Para manter tudo simples, você usa a API de registro do Android nesta tarefa, em vez da biblioteca Timber.

  1. Abra o aplicativo AndroidTrivia no último tutorial ou baixe o código da solução AndroidTrivia no GitHub.
  2. Abra o arquivo TitleFragment.kt. Observe que o Android Studio pode mostrar erros de vinculação e erros de referência não resolvidos até que você reconstrua o aplicativo.
  3. Role para baixo até o método onCreateView(). Observe que é aqui que o layout do fragmento é inflado e ocorre a vinculação de dados.
  4. Adicione uma instrução de registro ao método onCreateView(), entre a linha setHasOptionsMenu() e a chamada final para retornar: 
setHasOptionsMenu(true)

Log.i("TitleFragment", "onCreateView called")

return binding.root
  1. Logo abaixo do método onCreateView(), adicione instruções de registro para cada um dos métodos de ciclo de vida do fragmento restantes. Aqui está o código: 
override fun onAttach(context: Context?) {
   super.onAttach(context)
   Log.i("TitleFragment", "onAttach called")
}
override fun onCreate(savedInstanceState: Bundle?) {
   super.onCreate(savedInstanceState)
   Log.i("TitleFragment", "onCreate called")
}
override fun onActivityCreated(savedInstanceState: Bundle?) {
   super.onActivityCreated(savedInstanceState)
   Log.i("TitleFragment", "onActivityCreated called")
}
override fun onStart() {
   super.onStart()
   Log.i("TitleFragment", "onStart called")
}
override fun onResume() {
   super.onResume()
   Log.i("TitleFragment", "onResume called")
}
override fun onPause() {
   super.onPause()
   Log.i("TitleFragment", "onPause called")
}
override fun onStop() {
   super.onStop()
   Log.i("TitleFragment", "onStop called")
}
override fun onDestroyView() {
   super.onDestroyView()
   Log.i("TitleFragment", "onDestroyView called")
}
override fun onDetach() {
   super.onDetach()
   Log.i("TitleFragment", "onDetach called")
}
  1. Compile e execute o aplicativo e abra o Logcat.
  2. Digite I/TitleFragment no campo de pesquisa para filtrar o registro. Quando o aplicativo é iniciado, o Logcat se parece com a seguinte captura de tela:

Aqui você pode ver todo o ciclo de vida de inicialização do fragmento, incluindo estes retornos de chamada:

  1. Toque no botão Play para prosseguir para o jogo de perguntas e respostas e observe o Logcat agora.

Abrindo o próximo fragmento faz com que o fragmento do título seja fechado e estes métodos de ciclo de vida sejam chamados:

  1. No aplicativo, toque no botão Acima (a seta no canto superior esquerdo da tela) para retornar ao fragmento do título.


    Desta vez, onAttach() e onCreate() provavelmente não são chamados para iniciar o fragmento. O objeto de fragmento ainda existe e ainda está anexado à atividade de seu proprietário, então o ciclo de vida começa novamente com onCreateView().
  2. Pressione o botão Home do dispositivo. Observe no Logcat que apenas onPause() e onStop() são chamados. Este é o mesmo comportamento da atividade: Voltar para casa coloca a atividade e o fragmento em segundo plano.
  3. Use a tela Recentes para retornar ao aplicativo. Assim como aconteceu com a atividade, os métodos onStart() e onResume() são chamados para retornar o fragmento ao primeiro plano.

Projeto Android Studio: DessertClickerLogs

Ciclo de vida da atividade

Registro com registro

Registrando com Timber

Timber é uma biblioteca de registro com várias vantagens sobre a API de registro do Android. Em particular, a biblioteca Timber:

Para usar Timber, adicione sua dependência ao arquivo Gradle e estenda a classe Application para inicializá-lo:

Documentação para desenvolvimento em Android:

De outros:

Esta seção lista as possíveis tarefas de casa para os alunos que estão trabalhando neste tutorial como parte de um curso ministrado por um instrutor.

Altere um aplicativo

Abra o aplicativo DiceRoller na Lição 1. (Você pode baixar o aplicativo DiceRoller aqui se não tiver o aplicativo). Adicione suporte de Timber a esse aplicativo, usando o mesmo processo que você fez para o aplicativo DessertClicker . Substitua todos os retornos de chamada do ciclo de vida e adicione mensagens de registro para cada retorno de chamada.

Responda estas perguntas

Pergunta 1

Qual dos seguintes NÃO é um estado de ciclo de vida de atividade?

Pergunta 2

Qual método de ciclo de vida é chamado para tornar uma atividade visível?

Pergunta 3

Qual método de ciclo de vida é chamado para dar um foco de atividade?

Pergunta 4

Quando onCreate() é chamado em uma atividade?

Envie seu aplicativo para avaliação

Verifique se o aplicativo tem o seguinte:

Comece a próxima lição: 04.2: Situações de ciclo de vida complexas

Para obter enlaces para outros tutoriais neste curso, consulte a página de destino dos tutoriais Fundamentos de Android em Kotlin.