xref: /frameworks/base/docs/html-intl/intl/pt-br/guide/components/activities.jd

page.title=Atividades
page.tags=atividade,inteno
@jd:body

<div id="qv-wrapper">
<div id="qv">
<h2>Neste documento</h2>
<ol>
  <li><a href="#Creating">Criao de uma atividade</a>
    <ol>
      <li><a href="#UI">Implementao de uma interface do usurio</a></li>
      <li><a href="#Declaring">Declarao de uma atividade no manifesto</a></li>
    </ol>
  </li>
  <li><a href="#StartingAnActivity">Incio de uma atividade</a>
    <ol>
      <li><a href="#StartingAnActivityForResult">Incio de uma atividade de um resultado</a></li>
    </ol>
  </li>
  <li><a href="#ShuttingDown">Encerramento de uma atividade</a></li>
  <li><a href="#Lifecycle">Gerenciamento do ciclo de vida da atividade</a>
    <ol>
      <li><a href="#ImplementingLifecycleCallbacks">Implementao de retornos de chamada do ciclo de vida</a></li>
      <li><a href="#SavingActivityState">Gravao do estado da atividade</a></li>
      <li><a href="#ConfigurationChanges">Manipulao de alteraes de configurao</a></li>
      <li><a href="#CoordinatingActivities">Coordenao de atividades</a></li>
    </ol>
  </li>
</ol>

<h2>Classes principais</h2>
<ol>
  <li>{@link android.app.Activity}</li>
</ol>

<h2>Veja tambm</h2>
<ol>
  <li><a href="{@docRoot}guide/components/tasks-and-back-stack.html">Tarefas e pilha
de retorno</a></li>
</ol>

</div>
</div>



<p>{@link android.app.Activity}  um componente de aplicativo que fornece uma tela com a qual
os usurios podem interagir para fazer algo, como discar um nmero no telefone, tirar uma foto, enviar um e-mail
ou ver um mapa. Cada atividade recebe uma janela que exibe a interface do usurio. Geralmente, a janela
preenche a tela, mas pode ser menor que a tela e flutuar
sobre outras janelas.</p>

<p> Aplicativos geralmente possuem vrias atividades pouco vinculadas
entre si. Normalmente, uma atividade em um aplicativo  especificada como "principal",
que  a apresentada ao usurio ao iniciar o aplicativo pela primeira vez. Cada
atividade pode, ento, iniciar outra atividade para executar diferentes aes. Ao iniciar uma nova
atividade, a atividade anterior  interrompida, mas o sistema conserva a atividade
em uma pilha (a "pilha de retorno"). Quando uma atividade inicia, ela  enviada para a pilha de retorno
e obtm o foco do usurio. A pilha de retorno segue o mecanismo bsico de pilha UEPS (o ltimo que entra  o primeiro que sai).
Assim, quando o usurio terminar a atividade atual e apertar o boto <em>Voltar</em>,
ela sair da pilha ( destruda) e a atividade anterior ser retomada (a pilha de retorno
 discutida em mais detalhes no documento <a href="{@docRoot}guide/components/tasks-and-back-stack.html">Tarefas
e Pilha de Retorno</a>).</p>

<p>Quando uma atividade  interrompida devido ao incio de uma nova atividade, ela  notificada acerca dessa alterao de estado
por meio de mtodos de retorno de chamada do ciclo de vida da atividade.
H diversos mtodos de retorno de chamada que uma atividade pode receber devido a uma alterao
em seu estado &mdash; quando o sistema a est criando, interrompendo, retomando ou destruindo &mdash; e cada
retorno de chamada oferece uma oportunidade de executar trabalhos especficos
adequados a essa alterao de estado. Por exemplo: quando interrompida, a atividade deve liberar
todos os objetos grandes, como conexes com a rede ou com um banco de dados. Quando a atividade for retomada, ser possvel
readquirir os recursos necessrios e retomar as aes interrompidas. Essas transies de estado
so parte do ciclo de vida da atividade.</p>

<p>O restante deste documento discute o bsico sobre a compilao e o uso de uma atividade,
incluindo uma discusso completa sobre o funcionamento do ciclo de vida da atividade para gerenciar adequadamente
a transio entre os diversos estados da atividade.</p>



<h2 id="Creating">Criao de uma atividade</h2>

<p>Para criar uma atividade,  preciso criar uma subclasse de {@link android.app.Activity}
(ou uma respectiva subclasse existente). Na subclasse,  preciso implementar um mtodo de retorno de chamada
que o sistema chama quando ocorre a transio entre os diversos estados de seu ciclo de vida,
como na criao, interrupo, retomada ou destruio da atividade. Os dois mtodos mais importantes
de retorno de chamada so:</p>

<dl>
  <dt>{@link android.app.Activity#onCreate onCreate()}</dt>
  <dd> preciso implementar esse mtodo. O sistema o chama ao criar
a atividade. Na implementao,  preciso inicializar os componentes essenciais
da atividade.
    E, fundamentalmente,  quando se deve chamar {@link android.app.Activity#setContentView
setContentView()} para definir o layout da interface do usurio da atividade.</dd>
  <dt>{@link android.app.Activity#onPause onPause()}</dt>
  <dd>O sistema chama esse mtodo como o primeiro indcio de que o usurio est saindo
da atividade (embora no seja sempre uma indicao de que a atividade ser destruda).  quando geralmente
se deve confirmar qualquer alterao que deva persistir alm da sesso do usurio atual (porque
o usurio pode no retornar).</dd>
</dl>

<p>H outros mtodos de retorno de chamada do ciclo de vida que se pode usar para oferecer
uma experincia fluida ao usurio entre atividades e manipular interrupes inesperadas que venham a parar
ou at a destruir a atividade. Todos os mtodos de retorno de chamada do ciclo de vida sero discutidos mais adiante
na seo sobre <a href="#Lifecycle">Gerenciamento do ciclo de vida da atividade</a>.</p>



<h3 id="UI">Implementao de uma interface do usurio</h3>

<p> A interface do usurio de uma atividade  fornecida por uma hierarquia de objetos &mdash; de vistas derivados
da classe {@link android.view.View}.  Cada vista controla um espao retangular especfico
dentro da janela da atividade e pode responder  interao com o usurio. Por exemplo: uma vista pode ser
um boto que inicia uma ao quando o usurio toca nele.</p>

<p>O Android oferece algumas vistas prontas que podem ser usadas para projetar e organizar
o layout. "Widgets" so vistas que fornecem elementos visuais (e interativos)  tela,
como um boto, um campo de texto, uma caixa de seleo ou apenas uma imagem. "Layouts" so vistas derivadas de {@link
android.view.ViewGroup} que oferecem um modelo de layout exclusivo para suas vistas filhas,
como um layout linear, um layout em grade ou um layout relativo. Tambm  possvel definir como subclasse as classes
{@link android.view.View} e {@link android.view.ViewGroup} (ou subclasses existentes) para criar widgets e layouts prprios
e aplic-los no layout da atividade.</p>

<p>A forma mais comum de definir um layout usando vistas  com um arquivo de layout XML salvo
nos recursos do aplicativo. Assim,  possvel manter o projeto da interface do usurio separado
do cdigo fonte que define o comportamento da atividade.  possvel definir o layout como a IU da atividade
com {@link android.app.Activity#setContentView(int) setContentView()}, passando
o ID de recurso do layout. No entanto, tambm  possvel criar novas {@link android.view.View}s
no cdigo da atividade e compilar uma hierarquia de vistas inserindo novas {@link
android.view.View}s em um {@link android.view.ViewGroup} e, em seguida, usar esse layout passando a raiz
{@link android.view.ViewGroup} para {@link android.app.Activity#setContentView(View)
setContentView()}.</p>

<p>Para obter mais informaes sobre a criao de uma interface do usurio, consulte a documentao <a href="{@docRoot}guide/topics/ui/index.html">Interface do Usurio</a>.</p>



<h3 id="Declaring">Declarao de uma atividade no manifesto</h3>

<p> preciso declarar a atividade no arquivo de manifesto para torn-la
acessvel para o sistema. Para declarar a atividade, abra o arquivo de manifesto e adicione um elemento <a href="{@docRoot}guide/topics/manifest/activity-element.html">{@code &lt;activity&gt;}</a>
como filho do elemento
<a href="{@docRoot}guide/topics/manifest/application-element.html">{@code &lt;application&gt;}</a>. Por exemplo:</p>

<pre>
&lt;manifest ... &gt;
  &lt;application ... &gt;
      &lt;activity android:name=".ExampleActivity" /&gt;
      ...
  &lt;/application ... &gt;
  ...
&lt;/manifest &gt;
</pre>

<p>Existem outros atributos que podem ser includos nesse elemento para definir propriedades
como o rtulo da atividade, um cone para a atividade ou um tema para estilizar a IU da atividade.
 O atributo <a href="{@docRoot}guide/topics/manifest/activity-element.html#nm">{@code android:name}</a>
  o nico atributo obrigatrio &mdash; ele especifica o nome de classe da atividade. Depois
de publicar o aplicativo, no se deve alterar-lhe o nome porque, se isso acontecer, podem ocorrer danos
em algumas funcionalidades, como os atalhos do aplicativo (leia a publicao do blogue <a href="http://android-developers.blogspot.com/2011/06/things-that-cannot-change.html">Coisas
que no podem mudar</a>).</p>

<p>Consulte a referncia do elemento <a href="{@docRoot}guide/topics/manifest/activity-element.html">{@code &lt;activity&gt;}</a>
para obter mais informaes sobre como declarar a atividade no manifesto.</p>


<h4>Uso de filtros de intenes</h4>

<p>Um elemento <a href="{@docRoot}guide/topics/manifest/activity-element.html">{@code
&lt;activity&gt;}</a> tambm pode especificar vrios filtros de intenes &mdash; usando o elemento <a href="{@docRoot}guide/topics/manifest/intent-filter-element.html">{@code
&lt;intent-filter&gt;}</a> &mdash; para declarar o modo com que os componentes de aplicativo
podem ativ-lo.</p>

<p>Ao criar um novo aplicativo com as ferramentas do Android SDK, o esboo da atividade
criado contm automaticamente um filtro de inteno que declara que a atividade responde
 ao "main" (principal) e deve ser colocada na categoria "launcher (inicializador). O filtro de inteno
tem a seguinte aparncia:</p>

<pre>
&lt;activity android:name=".ExampleActivity" android:icon="@drawable/app_icon"&gt;
    &lt;intent-filter&gt;
        &lt;action android:name="android.intent.action.MAIN" /&gt;
        &lt;category android:name="android.intent.category.LAUNCHER" /&gt;
    &lt;/intent-filter&gt;
&lt;/activity&gt;
</pre>

<p>O elemento <a href="{@docRoot}guide/topics/manifest/action-element.html">{@code
&lt;action&gt;}</a> especifica que este  o principal ponto de entrada do aplicativo. O elemento <a href="{@docRoot}guide/topics/manifest/category-element.html">{@code
&lt;category&gt;}</a> especifica que essa atividade deve ser listada no inicializador do aplicativo
do sistema (para permitir que os usurios iniciem essa atividade).</p>

<p>Se pretende-se que o aplicativo seja autnomo e que no permita que outros aplicativos ativem
suas atividades, no ser necessrio nenhum outro filtro de inteno. S uma atividade deve ter
a ao "main" e a categoria "launcher", como no exemplo anterior. As atividades
que no devem estar disponveis a outros aplicativos no devem ter filtros de inteno, j que  possvel
inici-las por meio de intenes explcitas (conforme discutido na seo a seguir).</p>

<p>No entanto, se a atividade deve responder a intenes implcitas derivadas de outros aplicativos
(e do aplicativo em questo),  preciso definir filtros de intenes adicionais
para a atividade. Para cada tipo de inteno que deve responder,  preciso incluir um <a href="{@docRoot}guide/topics/manifest/intent-filter-element.html">{@code
&lt;intent-filter&gt;}</a> que contenha um elemento
<a href="{@docRoot}guide/topics/manifest/action-element.html">{@code
&lt;action&gt;}</a> e, opcionalmente, um elemento <a href="{@docRoot}guide/topics/manifest/category-element.html">{@code
&lt;category&gt;}</a> e/ou um elemento <a href="{@docRoot}guide/topics/manifest/data-element.html">{@code
&lt;data&gt;}</a>. Esses elementos especificam o tipo de inteno a que a atividade pode
responder.</p>

<p>Para obter mais informaes sobre a forma com que as atividades podem responder a intenes, consulte o documento
<a href="{@docRoot}guide/components/intents-filters.html">Intenes e filtros de intenes</a>.</p>



<h2 id="StartingAnActivity">Incio de uma atividade</h2>

<p>Para iniciar outra atividade,  possvel chamar {@link android.app.Activity#startActivity
startActivity()} passando uma {@link android.content.Intent} que descreva a atividade
que se deseja iniciar. A inteno especifica a atividade exata que deve ser iniciada ou descreve o tipo
de ao que ela deve executar (e o sistema seleciona a atividade adequada,
que
pode ser at de um outro aplicativo). Uma inteno tambm pode portar pequenas quantidades de dados
a serem usados pela atividade iniciada.</p>

<p>Ao trabalhar no aplicativo, frequentemente ser necessrio iniciar uma atividade conhecida.
 Para isso, pode-se criar uma inteno que defina explicitamente a atividade que deve ser iniciada
por meio de um nome de classe. Por exemplo, a seguir  demonstrado como uma atividade inicia outra atividade de nome {@code
SignInActivity}:</p>

<pre>
Intent intent = new Intent(this, SignInActivity.class);
startActivity(intent);
</pre>

<p>No entanto, o aplicativo tambm pode ter que executar algumas aes, como enviar um e-mail,
mensagem de texto ou atualizao de status usando os dados da atividade em questo. Nesse caso, o aplicativo
pode no ter suas prprias atividades para executar tais aes; para isso, pode-se aproveitar as atividades
fornecidas por outros aplicativos do dispositivo que podem executar essas aes. Esses so os casos
em que as intenes so muito importantes &mdash;  possvel criar uma inteno que descreva
uma ao a executar para que o sistema
inicie a atividade apropriada de outro aplicativo. Se houver
mais de uma atividade que possa manipular a inteno, o usurio poder escolher qual usar. Por exemplo:
 se quiser que o usurio envie uma mensagem de e-mail,  possvel criar
a seguinte inteno:</p>

<pre>
Intent intent = new Intent(Intent.ACTION_SEND);
intent.putExtra(Intent.EXTRA_EMAIL, recipientArray);
startActivity(intent);
</pre>

<p>O {@link android.content.Intent#EXTRA_EMAIL} adicionado  inteno  uma matriz de sequncia
de endereos de e-mail para os quais o e-mail poder ser enviado. Quando um aplicativo de e-mail responde  essa inteno,
ele l a matriz de sequncia fornecida no extra e a coloca no campo "para"
do formulrio de composio do e-mail. Nessa situao, a atividade do aplicativo de e-mail inicia e, quando o usurio termina o trabalho,
sua atividade  retomada.</p>




<h3 id="StartingAnActivityForResult">Incio de uma atividade para um resultado</h3>

<p>s vezes,  necessrio receber um resultado de alguma atividade iniciada. Nesse caso,
 inicie a atividade chamando {@link android.app.Activity#startActivityForResult
startActivityForResult()} (em vez de {@link android.app.Activity#startActivity
 startActivity()}). Para receber o resultado de uma atividade
subsequente, implemente o mtodo de retorno de chamada
{@link android.app.Activity#onActivityResult onActivityResult()}. Quando a atividade subsequente estiver concluda, ela retornar um resultado em uma {@link
android.content.Intent} para o mtodo
{@link android.app.Activity#onActivityResult onActivityResult()}.</p>

<p>Por exemplo, talvez voc queira que o usurio escolha um dos contatos dele, deste modo, a atividade poder
fazer algo com as informaes naquele contato. A seguir expe-se como criar uma inteno desse tipo
e manipular o resultado:</p>

<pre>
private void pickContact() {
    // Create an intent to "pick" a contact, as defined by the content provider URI
    Intent intent = new Intent(Intent.ACTION_PICK, Contacts.CONTENT_URI);
    startActivityForResult(intent, PICK_CONTACT_REQUEST);
}

&#64;Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    // If the request went well (OK) and the request was PICK_CONTACT_REQUEST
    if (resultCode == Activity.RESULT_OK &amp;&amp; requestCode == PICK_CONTACT_REQUEST) {
        // Perform a query to the contact's content provider for the contact's name
        Cursor cursor = getContentResolver().query(data.getData(),
        new String[] {Contacts.DISPLAY_NAME}, null, null, null);
        if (cursor.moveToFirst()) { // True if the cursor is not empty
            int columnIndex = cursor.getColumnIndex(Contacts.DISPLAY_NAME);
            String name = cursor.getString(columnIndex);
            // Do something with the selected contact's name...
        }
    }
}
</pre>

<p>Esse exemplo mostra a lgica bsica que deve ser usada no mtodo {@link
android.app.Activity#onActivityResult onActivityResult()} para manipular
o resultado de uma atividade. A primeira condio verifica se a solicitao foi bem-sucedida &mdash; se for,
o {@code resultCode} ser {@link android.app.Activity#RESULT_OK} &mdash; e se a solicitao
a que esse resultado responder for desconhecida &mdash;, nesse caso, o {@code requestCode} corresponder
ao segundo parmetro com {@link android.app.Activity#startActivityForResult
startActivityForResult()}. A partir da, o cdigo manipula o resultado da atividade com uma consulta
dos dados retornados em uma {@link android.content.Intent} (o parmetro {@code data}).</p>

<p>Nesse momento, um {@link
android.content.ContentResolver} executa uma consulta em um provedor de contedo, que retorna
um {@link android.database.Cursor} que permite a leitura dos dados consultados. Para obter mais informaes,
consulte o documento <a href="{@docRoot}guide/topics/providers/content-providers.html">Provedores de contedo</a>.</p>

<p>Para obter mais informaes sobre intenes, consulte o documento
<a href="{@docRoot}guide/components/intents-filters.html">Intenes e filtros de intenes</a>.</p>


<h2 id="ShuttingDown">Encerramento de uma atividade</h2>

<p>Para encerrar uma atividade, chame o mtodo {@link android.app.Activity#finish
finish()}. Tambm  possvel encerrar uma atividade separada iniciada anteriormente chamando
{@link android.app.Activity#finishActivity finishActivity()}.</p>

<p class="note"><strong>Observao:</strong> na maioria dos casos, no se deve finalizar explicitamente
uma atividade usando esses mtodos. Conforme discutido na seo anterior sobre o ciclo de vida da atividade,
o sistema Android gerencia a vida de uma atividade, portanto no  necessrio finalizar
as atividades. Chamar esses mtodos poderia afetar negativamente a experincia
do usurio esperada e isso s deve ser usado quando realmente no se desejar que o usurio
retorne a essa instncia da atividade.</p>


<h2 id="Lifecycle">Gerenciamento do ciclo de vida da atividade</h2>

<p>O gerenciamento do ciclo de vida das atividades por meio da implementao
de mtodos de retorno de chamada
 essencial para desenvolver um aplicativo flexvel. O ciclo de vida de uma atividade  diretamente afetado
por sua associao a outras atividades, sua tarefa e sua pilha de retorno.</p>

<p>Uma atividade pode existir essencialmente em trs estados:</p>

<dl>
  <dt><i>Retomada</i></dt>
    <dd>A atividade est em primeiro plano na tela e tem o foco do usurio (em geral,
chama-se esse estado de "em execuo).</dd>

  <dt><i>Pausada</i></dt>
    <dd>A atividade ainda est visvel, mas outra atividade est em primeiro plano e tem o foco. Ou seja,
outra atividade est visvel por cima desta e est parcialmente transparente
ou no cobre inteiramente a tela. Uma atividade pausada est totalmente ativa (o objeto
{@link android.app.Activity} est retido na memria, mantm todas as informaes de estado e do membro e permanece anexado
ao gerenciador de janela), mas pode ser eliminada pelo sistema em situaes de memria extremamente baixa.</dd>

  <dt><i>Interrompida</i></dt>
    <dd>A atividade est totalmente suplantada por outra (a atividade passa para
"segundo plano"). Uma atividade interrompida ainda est ativa (o objeto
{@link android.app.Activity} est retido na memria, mantm todas as informaes de estado e do membro, mas <em>no</em> est
anexado ao gerenciador de janelas). No entanto, ela no fica mais visvel para o usurio
e pode ser eliminada pelo sistema se a memria for necessria em outro processo.</dd>
</dl>

<p>Se uma atividade estiver pausada ou interrompida, o sistema poder descart-la da memria solicitando a
finalizao do processo (chamando seu mtodo {@link android.app.Activity#finish finish()}) ou simplesmente
eliminando-o.  Quando a atividade for reaberta (depois de finalizada ou eliminada), ele dever ser
totalmente recriada.</p>



<h3 id="ImplementingLifecycleCallbacks">Implementao de retornos de chamada do ciclo de vida</h3>

<p>Quando uma atividade transita entre os diferentes estados descritos acima, ela  notificada
por meio de vrios mtodos de retorno de chamada. Todos os mtodos de retorno de chamada so ganchos
que podem ser substitudos para executar um trabalho adequado quando o estado da atividade muda. O esqueleto de atividade
a seguir contm cada um dos mtodos do ciclo de vida fundamentais:</p>


<pre>
public class ExampleActivity extends Activity {
    &#64;Override
    public void {@link android.app.Activity#onCreate onCreate}(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        // The activity is being created.
    }
    &#64;Override
    protected void {@link android.app.Activity#onStart onStart()} {
        super.onStart();
        // The activity is about to become visible.
    }
    &#64;Override
    protected void {@link android.app.Activity#onResume onResume()} {
        super.onResume();
        // The activity has become visible (it is now "resumed").
    }
    &#64;Override
    protected void {@link android.app.Activity#onPause onPause()} {
        super.onPause();
        // Another activity is taking focus (this activity is about to be "paused").
    }
    &#64;Override
    protected void {@link android.app.Activity#onStop onStop()} {
        super.onStop();
        // The activity is no longer visible (it is now "stopped")
    }
    &#64;Override
    protected void {@link android.app.Activity#onDestroy onDestroy()} {
        super.onDestroy();
        // The activity is about to be destroyed.
    }
}
</pre>

<p class="note"><strong>Observao:</strong> a implementao desses mtodos do ciclo de vida
deve sempre chamar a implementao da superclasse antes de realizar qualquer trabalho, conforme ilustrado no exemplo acima.</p>

<p>Juntos, esses mtodos definem todo o ciclo de vida da atividade. Ao implement-los,
 possvel monitorar trs loops aninhados no ciclo de vida da atividade: </p>

<ul>
<li><b>Todo o tempo de vida</b> de uma atividade acontece entre a chamada de {@link
android.app.Activity#onCreate onCreate()} e a chamada de {@link
android.app.Activity#onDestroy}. A atividade deve executar configurao
de estado "global" (como definindo layout) em {@link android.app.Activity#onCreate onCreate()}
e liberar todos os recursos restantes em {@link android.app.Activity#onDestroy}. Por exemplo: se a sua atividade
tiver um encadeamento em execuo em segundo plano para baixar dados da rede, ela pode
cri-lo em {@link android.app.Activity#onCreate onCreate()} e, em seguida, interromp-lo em {@link
android.app.Activity#onDestroy}.</li>

<li><p>O <b>tempo de vida visvel</b> de uma atividade acontece entre a chamada de {@link
android.app.Activity#onStart onStart()} e a chamada de {@link
android.app.Activity#onStop onStop()}. Durante esse tempo, o usurio pode ver a atividade
na tela e interagir com ela. Por exemplo: {@link android.app.Activity#onStop onStop()}  chamado
quando uma nova atividade inicia e esta no fica mais visvel. Entre esses dois mtodos,  possvel
manter os recursos necessrios para exibir a atividade ao usurio. Por exemplo: voc pode registrar
um {@link android.content.BroadcastReceiver} em {@link
android.app.Activity#onStart onStart()} para monitorar as alteraes que afetem a IU e cancelar o registro
 em {@link android.app.Activity#onStop onStop()} quando o usurio no puder mais ver
o que voc est exibindo. O sistema pode chamar {@link android.app.Activity#onStart onStart()} e {@link
android.app.Activity#onStop onStop()} vrias vezes durante todo o tempo de vida de uma atividade
enquanto ela alterna entre visvel e oculta ao usurio.</p></li>

<li><p>O <b>tempo de vida em primeiro plano</b> de uma atividade ocorre entre a chamada de {@link
android.app.Activity#onResume onResume()} e a chamada de {@link android.app.Activity#onPause
onPause()}. Durante esse tempo, a atividade est na frente de todas as outras atividades na tela
e tem o foco de interao do usurio.  Frequentemente, uma atividade pode transitar entre o primeiro e
o segundo plano &mdash; por exemplo, {@link android.app.Activity#onPause onPause()}  chamado quando o dispositivo est em suspenso
ou quando uma caixa de dilogo  exibida. Como esse estado pode transitar frequentemente, o cdigo nesses dois mtodos deve
ser bem leve para evitar transies lentas que faam o usurio esperar.</p></li>
</ul>

<p>A figura 1 ilustra esses loops e os caminhos que uma atividade pode tomar entre os estados.
Os retngulos representam os mtodos de retorno de chamada que podem ser implementados para executar operaes
quando a atividade transita entre estados. <p>

<img src="{@docRoot}images/activity_lifecycle.png" alt="" />
<p class="img-caption"><strong>Figura 1.</strong> Ciclo de vida da atividade.</p>

<p>Os mesmos mtodos de retorno de chamada do ciclo de vida so listados na tabela 1, que descreve cada um deles
em mais detalhes e localiza cada um dentro
do ciclo de vida geral da atividade, inclusive se o sistema puder eliminar a atividade depois
da concluso do mtodo de retorno de chamada.</p>

<p class="table-caption"><strong>Tabela 1.</strong> Resumo dos mtodos de retorno de chamada
do ciclo de vida da atividade.</p>

<table border="2" width="85%" frame="hsides" rules="rows">
<colgroup align="left" span="3"></colgroup>
<colgroup align="left"></colgroup>
<colgroup align="center"></colgroup>
<colgroup align="center"></colgroup>

<thead>
<tr><th colspan="3">Mtodo</th> <th>Descrio</th> <th>Eliminvel depois de?</th> <th>Prximo</th></tr>
</thead>

<tbody>
<tr>
  <td colspan="3" align="left"><code>{@link android.app.Activity#onCreate onCreate()}</code></td>
  <td>Chamado quando a atividade  criada pela primeira vez.
       quando deve-se fazer toda a configurao esttica normal &mdash;
criar vistas, vincular dados a listas etc.  Esse mtodo recebe
um objeto Bundle (pacote) contendo o estado anterior da atividade, se esse
estado for capturado (consulte <a href="#actstate">Gravao do estado da atividade</a>
mais adiante).
      <p>Sempre seguido de {@code onStart()}.</p></td>
  <td align="center">No</td>
      <td align="center">{@code onStart()}</td>
</tr>

<tr>
   <td rowspan="5" style="border-left: none; border-right: none;">&nbsp;&nbsp;&nbsp;&nbsp;</td>
   <td colspan="2" align="left"><code>{@link android.app.Activity#onRestart
onRestart()}</code></td>
   <td>Chamado depois que atividade tiver sido interrompida, logo antes de ser
reiniciada.
       <p>Sempre seguido de {@code onStart()}.</p></td>
   <td align="center">No</td>
   <td align="center">{@code onStart()}</td>
</tr>

<tr>
   <td colspan="2" align="left"><code>{@link android.app.Activity#onStart onStart()}</code></td>
   <td>Chamado logo antes de a atividade se tornar visvel ao usurio.
       <p>Seguido de {@code onResume()} se a atividade
for para segundo plano ou {@code onStop()} se ficar oculta.</p></td>
    <td align="center">No</td>
    <td align="center">{@code onResume()} <br/>ou<br/> {@code onStop()}</td>
</tr>

<tr>
   <td rowspan="2" style="border-left: none;">&nbsp;&nbsp;&nbsp;&nbsp;</td>
   <td align="left"><code>{@link android.app.Activity#onResume onResume()}</code></td>
   <td>Chamado logo antes de a atividade iniciar
a interao com o usurio.  Nesse ponto, a atividade estar
no topo da pilha de atividades com a entrada do usurio direcionada a ela.
       <p>Sempre seguido de {@code onPause()}.</p></td>
   <td align="center">No</td>
   <td align="center">{@code onPause()}</td>
</tr>

<tr>
   <td align="left"><code>{@link android.app.Activity#onPause onPause()}</code></td>
   <td>Chamado quando o sistema est prestes a retomar
outra atividade.  Esse mtodo normalmente  usado para confirmar alteraes
no salvas a dados persistentes, animaes interrompidas e outras coisas que talvez
estejam consumindo CPU e assim por diante.  Ele sempre deve fazer tudo bem rapidamente porque
a prxima atividade no ser retomada at ela retornar.
       <p>Seguido de {@code onResume()} se a atividade
retornar para a frente ou de {@code onStop()} se ficar
invisvel ao usurio.</td>
   <td align="center"><strong style="color:#800000">Sim</strong></td>
   <td align="center">{@code onResume()} <br/>ou<br/> {@code onStop()}</td>
</tr>

<tr>
   <td colspan="2" align="left"><code>{@link android.app.Activity#onStop onStop()}</code></td>
   <td>Chamado quando a atividade no est mais visvel ao usurio.  Isso
pode acontecer porque ela est sendo destruda ou porque outra atividade
(uma existente ou uma nova) foi retomada e est cobrindo-a.
       <p>Seguido de {@code onRestart()} se a atividade
estiver voltando a interagir com o usurio
ou {@code onDestroy()} se estiver saindo.</p></td>
   <td align="center"><strong style="color:#800000">Sim</strong></td>
   <td align="center">{@code onRestart()} <br/>ou<br/> {@code onDestroy()}</td>
</tr>

<tr>
   <td colspan="3" align="left"><code>{@link android.app.Activity#onDestroy
onDestroy()}</code></td>
   <td>Chamado antes de a atividade ser destruda.   a ltima chamada
que a atividade receber.  Pode ser chamado porque a atividade
est finalizando (algum chamou <code>{@link android.app.Activity#finish
       finish()}</code> nela) ou porque o sistema est destruindo temporariamente essa instncia
da atividade para poupar espao.   possvel distinguir
entre essas duas situaes com o mtodo <code>{@link
       android.app.Activity#isFinishing isFinishing()}</code>.</td>
   <td align="center"><strong style="color:#800000">Sim</strong></td>
   <td align="center"><em>nada</em></td>
</tr>
</tbody>
</table>

<p>A coluna de nome "Eliminvel depois de?" indica se o sistema pode ou no
eliminar o processo que hospeda a atividade a qualquer momento <em>aps o mtodo retornar</em>
sem executar outra linha de cdigo da atividade.  Estes trs mtodos so marcados como "sim": ({@link
android.app.Activity#onPause
onPause()}, {@link android.app.Activity#onStop onStop()} e {@link android.app.Activity#onDestroy
onDestroy()}). Como {@link android.app.Activity#onPause onPause()}  o primeiro
dos trs, assim que a atividade  criada, {@link android.app.Activity#onPause onPause()} 
o ltimo mtodo que certamente ser chamado antes que o processo <em>possa</em> ser eliminado &mdash;
se o sistema precisar recuperar memria em uma emergncia, {@link
android.app.Activity#onStop onStop()} e {@link android.app.Activity#onDestroy onDestroy()} podero
no ser chamados. Portanto, deve-se usar {@link android.app.Activity#onPause onPause()} para gravar
dados persistentes cruciais (como edies do usurio) no armazenamento. No entanto, deve-se sempre ser seletivo
acerca das informaes que devem ser retidas durante {@link android.app.Activity#onPause onPause()} porque
qualquer procedimento de bloqueio nesse mtodo bloquear a transio para a prxima atividade e retardar
a experincia do usurio.</p>

<p> Os mtodos marcados como "No" na coluna <b>Eliminveis</b> protegem o processo que hospeda
a atividade. evitando a eliminao dele no momento em que  chamado.  Assim, uma atividade  eliminvel
do momento em que {@link android.app.Activity#onPause onPause()} retorna ao momento em que
{@link android.app.Activity#onResume onResume()}  chamado. Ela no ser eliminvel novamente at que
{@link android.app.Activity#onPause onPause()} seja chamado e retorne novamente. </p>

<p class="note"><strong>Observao:</strong> uma atividade tecnicamente no "eliminvel, por essa definio
na tabela 1, ainda pode ser eliminada pelo sistema &mdash; mas isso s ocorreria
em circunstncias extremas, quando no houvesse outra opo. A possibilidade de uma atividade ser eliminada
 discutida em mais detalhes no documento <a href="{@docRoot}guide/components/processes-and-threads.html">Processos
e encadeamentos</a>.</p>


<h3 id="SavingActivityState">Gravao do estado da atividade</h3>

<p>A introduo a <a href="#Lifecycle">Gerenciamento do ciclo de vida da atividade</a> menciona brevemente
que,
quando uma atividade  pausada ou interrompida, o estado da atividade  retido. Isso acontece porque
o objeto {@link android.app.Activity} continua mantido na memria quando a atividade est pausada
ou interrompida &mdash; todas as informaes sobre seus membros e estado atual ainda esto ativas. Assim, todas as alteraes
feitas pelo usurio dentro da atividade so retidas, de forma que, quando a atividade retornar
ao primeiro plano (quando  "retomada"), essas alteraes ainda estejam l.</p>

<p>No entanto, quando o sistema destri uma atividade para recuperar memria, o objeto {@link
android.app.Activity}  destrudo, por isso o sistema no pode simplesmente retom-la com seu estado
intacto. Em vez disso, o sistema tem que recriar o objeto {@link android.app.Activity} se o usurio
navegar de volta a ele. Ainda assim, o usurio no estar ciente
de que o sistema destruiu a atividade e recriou-a e, assim, provavelmente
esperar que a atividade esteja exatamente como antes. Nessa situao, para garantir que
as informaes importantes sobre o estado da atividade sejam preservadas, implementa-se um mtodo
adicional de retorno de chamada que permite salvar as informaes sobre o estado da atividade: {@link
android.app.Activity#onSaveInstanceState onSaveInstanceState()}.</p>

<p>O sistema chama {@link android.app.Activity#onSaveInstanceState onSaveInstanceState()}
antes de deixar a mensagem vulnervel  destruio. O sistema passa a esse mtodo
um {@link android.os.Bundle} no qual  possvel salvar
informaes de estado acerca da atividade, como pares nome-valor, usando mtodos como {@link
android.os.Bundle#putString putString()} e {@link
android.os.Bundle#putInt putInt()}. Em seguida, se o sistema eliminar o processo
do aplicativo e o usurio voltar  atividade, o sistema recriar a atividade e passar
o {@link android.os.Bundle} a {@link android.app.Activity#onCreate onCreate()} e a {@link
android.app.Activity#onRestoreInstanceState onRestoreInstanceState()}. Usando qualquer um desses mtodos,
 possvel extrair o estado salvo de {@link android.os.Bundle} e restaurar
o estado da atividade. Se no houver informaes de estado a restaurar, o {@link
android.os.Bundle} passado ser nulo (que  o caso quando a atividade  criada
pela primeira vez).</p>

<img src="{@docRoot}images/fundamentals/restore_instance.png" alt="" />
<p class="img-caption"><strong>Figura 2.</strong> As duas formas pelas quais uma atividade retorna ao foco
do usurio com seu estado intacto: ou a atividade  destruda e recriada em seguida  e ela deve restaurar
o estado salvo anteriormente , ou a atividade  interrompida e retomada em seguida  e o estado dela
permanece intacto.</p>

<p class="note"><strong>Observao:</strong> no h garantia nenhuma de que {@link
android.app.Activity#onSaveInstanceState onSaveInstanceState()} ser chamado antes de a atividade
ser destruda porque h casos em que no ser necessrio salvar o estado
(como quando o usurio sai da atividade usando o boto <em>Voltar</em>) porque o usurio est fechando
explicitamente
a atividade). Se o sistema chamar {@link android.app.Activity#onSaveInstanceState
onSaveInstanceState()}, ele o far antes de {@link
android.app.Activity#onStop onStop()} e possivelmente antes de {@link android.app.Activity#onPause
onPause()}.</p>

<p>No entanto, mesmo se voc no fizer nada e no implementar {@link
android.app.Activity#onSaveInstanceState onSaveInstanceState()}, parte do estado da atividade
ser restaurada pela implementao padro da classe {@link android.app.Activity} de {@link
android.app.Activity#onSaveInstanceState onSaveInstanceState()}. Especificamente, a implementao
padro chama o mtodo {@link
android.view.View#onSaveInstanceState onSaveInstanceState()} correspondente para cada {@link
android.view.View} no layout, o que permite que cada vista fornea informaes prprias sobre o que
deve ser salvo. Quase todo widget na estrutura do Android implementa esse mtodo
conforme o necessrio, de forma que qualquer alterao visvel na IU seja automaticamente salva e restaurada
ao criar a atividade. Por exemplo, o widget {@link android.widget.EditText} salva qualquer texto
inserido pelo usurio e o widget {@link android.widget.CheckBox} salva independente
de verificao. O nico trabalho necessrio ser fornecer um ID exclusivo (com
o atributo <a href="{@docRoot}guide/topics/resources/layout-resource.html#idvalue">{@code android:id}</a>) para cada widget que for salvar seu estado. Se o widget no salvar nenhum ID, o sistema
no poder salvar seu estado.</p>

<div class="sidebox-wrapper">
<div class="sidebox">
<p>Para fazer com que uma vista deixe explicitamente de salvar seu estado, defina o atributo
{@link android.R.attr#saveEnabled android:saveEnabled} como {@code "false"} ou chame
o mtodo {@link android.view.View#setSaveEnabled setSaveEnabled()}. Geralmente, no se deve
desativar isso, mas  possvel caso se deseje restaurar o estado da IU da atividade de forma diferente.</p>
</div>
</div>

<p>Embora a implementao padro de {@link
android.app.Activity#onSaveInstanceState onSaveInstanceState()} salve informaes teis sobre
a IU da atividade, talvez ainda seja necessrio substitu-la para salvar informaes adicionais.
Por exemplo: pode ser necessrio salvar valores de membro alterados durante a vida da atividade (possivelmente
correlacionados a valores restaurados na IU, mas os membros que retm esses valores de IU, por padro,
no so restaurados).</p>

<p>Como a implementao padro de {@link
android.app.Activity#onSaveInstanceState onSaveInstanceState()} ajuda a salvar o estado da IU,
se o mtodo for substitudo para salvar informaes de estado adicionais, deve-se sempre chamar a implementao
da superclasse de {@link android.app.Activity#onSaveInstanceState onSaveInstanceState()}
antes de fazer qualquer trabalho. Da mesma forma, deve-se tambm chamar a implementao da superclasse de {@link
android.app.Activity#onRestoreInstanceState onRestoreInstanceState()} se ela for substituda para que
a implementao padro possa restaurar estados da vista.</p>

<p class="note"><strong>Observao:</strong> Como nem sempre {@link android.app.Activity#onSaveInstanceState
onSaveInstanceState()}  chamado,
deve-se us-lo somente para registrar o estado temporrio da atividade (o estado
da IU) &mdash; nunca se deve us-lo para armazenar dados persistentes.  Em vez disso, deve-se usar {@link
android.app.Activity#onPause onPause()} para armazenar dados persistentes (como dados que devem ser salvos
em um banco de dados) quando o usurio sair da atividade.</p>

<p>Uma boa forma de testar a capacidade do aplicativo de restaurar seu estado  girar
o dispositivo para alterar a orientao da tela. Quando a orientao de tela muda, o sistema
destri e recria a atividade para aplicar recursos alternativos que podem ser disponibilizados
para a nova configurao de tela. Por esse motivo somente,  muito importante que a atividade
restaure completamente seu estado quando for recriada porque os usurios normalmente giram a tela
ao usar aplicativos.</p>


<h3 id="ConfigurationChanges">Manipulao de alteraes de configurao</h3>

<p>Algumas configuraes do dispositivo podem mudar em tempo de execuo (como A orientao da tela, disponibilidade
do teclado e idioma). Quando ocorre uma alterao, o Android recria a atividade em execuo
(o sistema chama {@link android.app.Activity#onDestroy} e, em seguida, chama {@link
android.app.Activity#onCreate onCreate()} imediatamente). Esse comportamento foi projetado
para ajudar o aplicativo a se adaptar a novas configuraes recarregando-o automaticamente
com recursos alternativos fornecidos pelo programador (como diferentes layouts
para orientaes e tamanhos de telas diferentes).</p>

<p>Se voc projetar adequadamente a atividade para manipular um reincio devido a uma alterao na orientao da tela
e restaurar o estado da atividade conforme descrito acima, o aplicativo ser mais resiliente a outros
eventos inesperados no ciclo de vida da atividade.</p>

<p>A melhor forma de manipular um reincio desse tipo
 salvar e restaurar o estado da atividade com {@link
 android.app.Activity#onSaveInstanceState onSaveInstanceState()} e {@link
android.app.Activity#onRestoreInstanceState onRestoreInstanceState()} (ou com {@link
android.app.Activity#onCreate onCreate()}), conforme abordado na seo anterior.</p>

<p>Para obter mais informaes sobre alteraes de configurao que podem ocorrer em tempo de execuo e como manipul-las,
leia o guia em <a href="{@docRoot}guide/topics/resources/runtime-changes.html">Tratamento de
alteraes em tempo de execuo</a>.</p>



<h3 id="CoordinatingActivities">Coordenao de atividades</h3>

 <p>Quando uma atividade inicia outra, ambas passam por transies no ciclo de vida. A primeira atividade
 pausada e interrompida (embora ela no seja interrompida se ainda estiver visvel em segundo plano) enquanto a outra
atividade  criada. Caso essas atividades compartilhem dados salvos em disco ou em outro lugar,  importante
compreender que a primeira atividade no  totalmente interrompida antes da criao da segunda.
Em vez disso, o processo de iniciar a segunda se sobrepe ao processo de interromper
a primeira.</p>

<p>A ordem dos retornos de chamada do ciclo de vida  bem definida, especialmente quando as duas atividades esto
no mesmo processo e uma est iniciando a outra. A seguir h a ordem das operaes que ocorrem quando a atividade A
inicia a atividade B: </p>

<ol>
<li>O mtodo {@link android.app.Activity#onPause onPause()} da atividade A  executado.</li>

<li>Os mtodos {@link android.app.Activity#onCreate onCreate()}, {@link
android.app.Activity#onStart onStart()} e {@link android.app.Activity#onResume onResume()}
da atividade B so executados em sequncia (a atividade B agora tem o foco do usurio).</li>

<li>Em seguida, se a atividade A no estiver mais visvel na tela, seu mtodo {@link
android.app.Activity#onStop onStop()}  executado.</li>
</ol>

 <p>Essa sequncia previsvel de retornos de chamada do ciclo de vida permite gerenciar a transio
de informaes de uma atividade para outra. Por exemplo: se voc for gravar em um banco de dados o momento em que
a primeira atividade  interrompida para que a atividade a seguir possa l-lo,  preciso realizar a gravao
no banco de dados durante {@link android.app.Activity#onPause onPause()} e no durante {@link
android.app.Activity#onStop onStop()}.</p>

<!--
<h2>Beginner's Path</h2>

<p>For more information about how Android maintains a history of activities and
enables user multitasking, continue with the <b><a
href="{@docRoot}guide/components/tasks-and-back-stack.html">Tasks and Back
Stack</a></b> document.</p>
-->