Android – Ciclo de vida de uma Atividade

Olá amigos do The Club, neste artigo estudaremos mais a fundo uma das classes mais importantes do Sistema Android, a Activity (Atividade). Nos artigos anteriores trabalhamos por padrão com apenas uma Atividade e especificamente com o Evento Oncreate(), ou seja, o evento que é executado no momento da criação da classe. Existem diversos eventos que devem ser trabalhados em uma Atividade, como por exemplo o OnStart(), OnExecute(), OnStop() entre outros.

Terei como base para escrever este artigo as informações contidas bo site oficial do Sistema Android

http://developer.android.com/guide/components/activities.html

Conceito de Atividade

Uma atividade é um componente de aplicação que fornece uma tela com a qual os usuários podem interagir, a fim de fazer alguma coisa, como discar para um número de telefone, tirar uma foto, enviar um e-mail ou visualizar um mapa. Cada atividade é dada uma janela na qual apresenta uma interface para o usuário. A janela tipicamente preenche a tela podendo ser menor do que a tela ou flutuando acima das outras. Uma aplicação geralmente consiste de múltiplas atividades que estão ligadas entre si. Cada atividade pode, então, iniciar outra atividade, a fim de executar ações diferentes.

Quando uma atividade é interrompida porque uma nova atividade é iniciada, ela é notificada dessa mudança de estado através de métodos da atividade de retorno de chamada do ciclo de vida. Existem vários métodos de retorno que uma atividade pode receber que estaremos aprendendo ao decorrer do artigo.

Entendendo o ciclo de uma Atividade

A Imagem 01 nos proporciona uma idéia geral do funcionamento de uma atividade, vejamos todas as etapas detalhadamente a seguir.

Figura 01: Ciclo de Vida de uma Atividade.

O ciclo de vida de uma atividade possui os seguintes métodos:

OnCreate()

O primeiro evento utilizado quando iniciamos a Atividade, no momento de sua criação. Este método é passado um objeto do tipo “Bundle” contendo o estado anterior de uma atividade, sendo sempre seguido pelo onStart().

OnStart()

Executado quando a atividade está visível para o usuário. Utiliza-se o onResume() se a atividade vem para o primeiro plano, ou o onStop() quando não está visível.

OnRestart()

Chamado quando uma atividade parou por algum motivo. Executando o OnStart() de uma forma automática.

OnResume()

Chamado apenas antes da atividade começar a interagir com o usuário. Neste ponto, a atividade está no topo da pilha de atividades.

OnPause()

Chamado quando o sistema está prestes a começar a retomar outra atividade.

OnStop()

Este método é chamado quando a atividade está sendo encerrada.

OnDestroy()

Método responsável por liberar da memória a atividade, sendo a última chamada que a mesma irá receber.

Em conjunto, estes métodos definem o ciclo de vida completo de uma atividade. Ao implementar esses métodos, você pode monitorar três loops aninhados no seu ciclo de vida:

·         A vida inteira de uma atividade acontece entre a chamada para onCreate() e a chamada para OnDestroy(). Sua atividade deve realizar a configuração de estado "global" (como a definição de layout) no onCreate(), e liberar todos os recursos restantes no onDestroy().

Exemplo: se sua atividade tem um segmento em execução em segundo plano para fazer download de dados a partir da rede, pode criar esse segmento no onCreate() e, em seguida, parar o segmento no evento onDestroy().

·         O tempo de vida visível de uma atividade acontece entre a chamada para OnStart() e a chamada para onStop(). Durante este tempo, o usuário pode ver e interagir com ela. Por exemplo, o onStop() é chamado quando uma nova atividade começa e esta não é mais visível. Entre estes dois métodos, você pode manter os recursos que são necessários para mostrar a atividade para o usuário.

·         O tempo de vida de primeiro plano de uma atividade acontece entre a chamada do método onResume() e a chamada para o método OnPause(). Durante este tempo, a atividade está na frente de todas as outras atividades na tela e tem o foco de entrada do usuário. Uma atividade pode fazer freqüentemente a transição de dentro e fora do plano.

Implementando os métodos de uma forma prática

Para isto abra seu Eclipse e clique em “File/New/Android Project” e crie um projeto em Android, recomendo a criação na versão 2.2 ou 2.3. Navegue até a atividade principal, no meu caso seria o caminho: “CiclodeVida\src\pct.CiclodeVida\CiclodeVidaActivity” e implemente os métodos criados anteriormente. Ver código completo a seguir.

package pct.CiclodeVida;

import android.app.Activity;

import android.os.Bundle;

public class CiclodeVidaActivity extends Activity

{

    @Override

    public void onCreate(Bundle savedInstanceState)

    {

        super.onCreate(savedInstanceState);

        setContentView(R.layout.main);

    }

       

    @Override

    protected void onStart()

    {

        super.onStart();

    }

   

    @Override

    protected void onResume()

    {

        super.onResume();

    }

   

    @Override

    protected void onPause()

    {

        super.onPause();

    }

   

    @Override

    protected void onStop()

    {

        super.onStop();

    }

    @Override

    protected void onDestroy()

    {

        super.onDestroy();

    }

}

Usaremos o LogCat, que nada mais é que uma janela que nos detalha de uma forma prática todos as tarefas executadas no sistema Android, para isto clique no menu “Window/Show View/Other” e selecione o item “LogCat”. Ver Imagem 02.

Figura 02: Selecionado o Item LogCat.

Codificaremos o exemplo criado anteriormente para facilitar a identificação dos métodos. Utilizaremos o método Log.i() que possui dois parâmetros do tipo texto, o primeiro seria a TAG para identificação da mensagem informativa e o segundo a própria mensagem que será exibida. Passaremos o nome de nossa Atividade e o método que está sendo executado respectivamente.

Ver código completo a seguir.

package pct.CiclodeVida;

import android.app.Activity;

import android.os.Bundle;

import android.util.Log;

public class CiclodeVidaActivity extends Activity

{

    @Override

    public void onCreate(Bundle savedInstanceState)

    {

        super.onCreate(savedInstanceState);

        setContentView(R.layout.main);

        Log.i("CiclodeVida","Método OnCreate()");

    }

       

    @Override

    protected void onStart()

    {

        super.onStart();

        Log.i("CiclodeVida","Método OnStart()");

    }

   

    @Override

    protected void onResume()

    {

        super.onResume();

        Log.i("CiclodeVida","Método OnResume()");

    }

   

    @Override

    protected void onPause()

    {

        super.onPause();

        Log.i("CiclodeVida","Método OnPause()");

    }

   

    @Override

    protected void onStop()

    {

        super.onStop();

        Log.i("CiclodeVida","Método OnStop()");

    }

    @Override

    protected void onDestroy()

    {

        super.onDestroy();

        Log.i("CiclodeVida","Método OnDestroy()");

    }

}

Ao executarmos o exemplo podemos conferir as etapas da criação e execução da Atividade. A Imagem 03 nos dá uma noção quando iniciamos a aplicação.

Figura 03: Evento OnCreate(), OnStart() e OnResume().

Clicando no botão “home” e ao voltarmos na mesma tela principal podemos conferir a execução dos eventos OnPause() e OnStop().

Ver Imagem 04 e 05.

Figura 04: Clicando no Botão Home.

Figura 05: Evento OnPause() e OnStop().

Para simular o evento OnDestroy() devemos fechar a aplicação teclando o ESC e abri-la novamente.

Figura 06: Evento OnDestroy().

Desta forma como foi explicada e aplicada a um exemplo prático fica fácil o entendimento do ciclo de vida de uma atividade.

Criando um exemplo com múltiplas atividades

Para entendermos melhor montarei um exemplo utilizando mais de uma atividade, sendo que cada tela possuirá a sua correspondente. Focaremos em um exemplo simples, no qual a tela principal possuirá um botão que chama a tela secundária. Crie um novo projeto em Android (como foi criado nos artigos anteriores) e adicione um botão na tela principal. Na tela secundária adicione outro para voltar no início. O Lay-out deverá ficar idêntico ao da Imagem 07.

Figura 07: Lay-Out do exemplo.

A maneira para criarmos uma atividade é muito simples, clique com o botão direito no caminho “src\pct.VariasAtividades” e escolha “New/Class”. Uma atividade nada mais é que uma classe que herda da classe Activity. Devemos utilizar o “extends” para indicar que a classe Secundaria está sendo herdada da classe Activity, ver código em seguida.

package pct.VariasAtividades;
import android.app.Activity;

public class Secundaria extends Activity
{
     @Override
     public void onCreate(Bundle savedInstanceState)
     {

         super.onCreate(savedInstanceState);
         setContentView(R.layout.secundaria);
     }

}

O segundo passo seria registrar a nova atividade criada anteriormente no arquivo “AndroidManifest.xml”, para que possamos posteriormente trabalhar com ela. Podemos fazer isto utilizando a IDE do Android, em “Application Nodes” clicando no botão “Add...” para criar a atividade desejada. Ver Imagem 08 e 09.

Figura 08: AndroidManifest.

Figura 09: Criando uma Atividade.

Depois de efetuar as etapas abordadas anteriormente clique sobre a atividade e em “Atributes for Secundaria(Activity)” no campo “Name” Escolha a Atividade “Secundaria.java” como referência.

Ver Imagem 10.

Figura 10: Atribuindo à classe “Secundaria.java”.

E o código XML correspondente ficou da seguinte maneira:

<activity android:name="Secundaria"> </activity>

Codificando o Projeto de Exemplo

A tela principal é aquela que servirá como base para chamar a Secundária. Programe no evento OnClick do botão o comando StartActivity() que tem como parâmetro o nome da Atividade principal seguido do nome da classe secundária, a qual devemos invocar. Devemos seguir a mesma lógica para programar o botão voltar na tela Secundária. Veja a seguir o código completo da aplicação.

Código referente à Tela Principal

package pct.VariasAtividades;

import android.app.Activity;

import android.content.Intent;

import android.os.Bundle;

import android.view.View;

import android.widget.Button;

public class VariasAtividadesActivity extends Activity

{

   @Override

   public void onCreate(Bundle savedInstanceState)

   {

     super.onCreate(savedInstanceState);

     setContentView(R.layout.main);

               

Button btConsultar = (Button)            findViewById(R.id.button1);

btConsultar.setOnClickListener(new View.OnClickListener()

     {

        @Override

        public void onClick(View v)

        {

startActivity(new Intent(VariasAtividadesActivity.this,Secundaria.class));

        }

     });

   }

}

Código referente à Tela Secundária

package pct.VariasAtividades;

import android.app.Activity;

import android.content.Intent;

import android.os.Bundle;

import android.view.View;

import android.widget.Button;

public class Secundaria extends Activity

{

   @Override

   public void onCreate(Bundle savedInstanceState)

   {

     super.onCreate(savedInstanceState);

     setContentView(R.layout.secundaria);

    

Button btConsultar = (Button)   findViewById(R.id.button1);

btConsultar.setOnClickListener(new View.OnClickListener()

     {

        @Override

        public void onClick(View v)

        {

startActivity(new  Intent(Secundaria.this,VariasAtividadesActivity.class));

     }

  });

 }

}

Conclusão

Vimos neste artigo o ciclo de vida da principal classe do Sistema Android, as denominadas Atividades. Estas classes possuem vários métodos importantes e necessários para o bom funcionamento do sistema. Neste caso abordamos de uma forma prática e rápida aplicando em um exemplo simples e não esquecendo de sempre manter o foco no aprendizado.

Um forte abraço e até o mês que vem!