Quando você começa a programar em uma linguagem como C ++ ou Java, a primeira coisa que é ensinada é o método principal, o ponto que o sistema operacional chamará quando iniciarmos nossa aplicação.
No Android não existe um método principal como tal, mas existem vários métodos de nossa atividade que serão chamados por SSOO quando ocorrerem eventos importantes. Neste capítulo, estudaremos em profundidade quais são esses eventos e como funcionam. o ciclo completo de uma atividade do Android. A documentação oficial oferece uma explicação extensa sobre este tópico, aqui estudaremos os elementos mais importantes junto com alguns erros comuns ao tratá-los.
O ciclo de vida do Android segue este esquema:
Eventos do ciclo de vida
- onCreate (pacote)
- Representa o momento em que a atividade é criada. Este método normalmente será gerado pelo assistente ao criar uma nova atividade no Android, e é onde criaremos tudo que a atividade precisará. Se salvamos anteriormente os dados da atividade em um objeto Bundle, podemos usá-lo para gerá-lo novamente. Normalmente não o usaremos.
- onStart ()
- A atividade irá prosseguir para estar na tela, embora não necessariamente visível. Se viermos de uma parada, passaremos por onRestart () primeiro.
- onRestart ()
- Anterior a onStart () quando chegamos de uma chamada a onStop ().
- Resumindo()
- A atividade vai começar responder à interação do usuário.
- onPause ()
- A atividade vai pare de responder à interação do usuário.
- onStop ()
- A atividade foi completamente para segundo plano.
- onDestroy ()
- A atividade será destruído e seus recursos liberados.
Quando precisarmos implementar um desses métodos, faremos isso acrescentando à nossa atividade com estes perfis:
public class MyActivity extends Activity {protected void onCreate (Bundle savedInstanceState) {super.onCreate (savedInstanceState); ...} protected void onStart () {super.onStart (); ...} protected void onRestart () {super.onRestart (); ...} protegido void onResume () {super.onResume (); ...} protected void onPause () {... super.onPause (); } protected void onStop () {... onStop (); } protected void onDestroy () {... super.onDestroy (); }}
É importante manter chamada de método da superclasse para não encontrar surpresas. As tarefas de cada evento que estão acima de nossa atividade devem ser mantidas. Esta chamada irá para o início dos eventos de entrada e para o final dos eventos de saída. Desta forma, evitaremos surpresas, pois os elementos da atividade de que necessitamos mas que não estarão sob nosso controle serão criados antes de usá-los, e serão destruídos posteriormente.
Não temos que adicionar todos os eventos, aqueles de que não precisamos usarão a implementação padrão. Os métodos que usaremos com frequência - e não é recomendado tocar nos outros - são onCreate, onPause e onRestart.
O significado de onCreate é claro: é o lugar onde carregaremos os recursos de que precisamos, as visualizações e tudo o mais que precisarmos. Para a saída, o único método que enfocaremos é onPause. A razão para evitar onStop e onDestroy é que não temos nenhum controle sobre eles. onPause será executado sempre que o aplicativo sair do primeiro plano, enquanto os outros dois serão executados pelo sistema operacional com base nas suas necessidades. Eles podem nunca ser executados! Isso é feito para evitar o custo de criar a atividade repetidamente se passarmos da atividade para a área de trabalho e vice-versa, e o sistema operacional só irá liberar os recursos usados se precisar deles, e não precisa atender a todos os processos abertos.
Isso implica que assumiremos que o aplicativo morrerá após a execução de onPause, e que é nosso última chance de salvar dados que precisamos salvar e interromper os serviços que estamos usando, como geolocalização. Se tivermos interrompido os serviços, o local apropriado para reiniciá-los é onRestart.
Os outros métodos não precisaremos usar muito. Um caso comum em que precisaremos será quando integramos bibliotecas de terceiros, como Facebook ou Flurry. Nestes casos, seremos solicitados a combinar os métodos de nossa atividade com o seu código. Por exemplo, para registrar uma sessão Flurry, seremos solicitados a iniciar a sessão no método onStart.
Algumas idéias úteis
- Lembre-se para que serve cada evento. Você sempre precisará de onCreate e, com frequência, de onPause e onResume para interromper e reiniciar os serviços que mais consomem.
- Não toque nos outros eventos se você não precisa expressamente.
- Não confie em onStop e onDestroy, eles podem nunca ser chamados. Salve tudo que você precisa em onPause.
- Evite usar variáveis estáticas não finais. O aplicativo ainda pode ser carregado quando você retornar e eles manterão os valores que deixaram para trás. Se você não tiver escolha a não ser usá-los, certifique-se de redefinir seus valores ao retornar ao primeiro plano.
Mais informação - Guia básico para programação em Android
