diff options
Diffstat (limited to 'docs/html-intl/intl/pt-br/training/basics/activity-lifecycle/stopping.jd')
| -rw-r--r-- | docs/html-intl/intl/pt-br/training/basics/activity-lifecycle/stopping.jd | 187 |
1 files changed, 187 insertions, 0 deletions
diff --git a/docs/html-intl/intl/pt-br/training/basics/activity-lifecycle/stopping.jd b/docs/html-intl/intl/pt-br/training/basics/activity-lifecycle/stopping.jd new file mode 100644 index 0000000..2eba377 --- /dev/null +++ b/docs/html-intl/intl/pt-br/training/basics/activity-lifecycle/stopping.jd @@ -0,0 +1,187 @@ +page.title=Interrompendo e reiniciando uma atividade +page.tags=ciclo de vida da atividade +helpoutsWidget=true + +trainingnavtop=true + +@jd:body + +<div id="tb-wrapper"> + <div id="tb"> + + <h2>Esta lição ensina a</h2> + <ol> + <li><a href="#Stop">Interromper sua atividade</a></li> + <li><a href="#Start">Iniciar/reiniciar sua atividade</a></li> + </ol> + + <h2>Leia também</h2> + <ul> + <li><a href="{@docRoot}guide/components/activities.html">Atividades</a> + </li> + </ul> + +<h2>Tente</h2> + +<div class="download-box"> + <a href="http://developer.android.com/shareables/training/ActivityLifecycle.zip" class="button">Baixar a demonstração</a> + <p class="filename">ActivityLifecycle.zip</p> +</div> + + </div> +</div> + +<p>Interromper e reiniciar adequadamente sua atividade é um processo importante no ciclo de vida da atividade +que garante que o usuário perceba que o aplicativo está sempre ativo e não perca o progresso. +Há alguns cenários fundamentais em que sua atividade é interrompida e reiniciada:</p> + +<ul> + <li>O usuário abre a janela Aplicativos Utilizados Recentemente e alterna de um aplicativo a outro. A +atividade em seu aplicativo atualmente em primeiro plano é interrompida. Se o usuário retornar ao +aplicativo pelo ícone de inicialização da tela inicial ou da janela Aplicativos Utilizados Recentemente, a atividade é reiniciada.</li> + <li>O usuário executar uma ação em seu aplicativo que inicia uma nova atividade. A atividade atual +é interrompida quando a segunda é criada. Se o usuário pressionar o botão <em>Voltar</em> +, a primeira atividade será reiniciada.</li> + <li>Se o usuário receber uma chamada telefônica enquanto estiver usando o seu aplicativo.</li> +</ul> + +<p>A classe {@link android.app.Activity} fornece dois métodos do ciclo de vida, {@link +android.app.Activity#onStop()} e {@link android.app.Activity#onRestart()}, que permite que você +decida exatamente como a atividade responderá à interrupção e reinicialização. Diferentemente do estado pausado, +que identifica obstruções parciais da interface de usuário, o estado interrompido garante que a interface não fique +visível e que o foco do usuário permaneça em outra atividade (ou mesmo outro aplicativo).</p> + +<p class="note"><strong>Observação:</strong> como o sistema retém a instância {@link android.app.Activity} +na memória quando interrompida, talvez não seja necessário implementar os métodos +{@link android.app.Activity#onStop()} e {@link android.app.Activity#onRestart()} (ou mesmo {@link +android.app.Activity#onStart()}. Para a maioria das atividades que são relativamente simples, a +atividade será interrompida e reiniciada normalmente e talvez seja necessário apenas usar {@link +android.app.Activity#onPause()} para pausar ações em andamento e desconectar dos recursos do sistema.</p> + +<img src="{@docRoot}images/training/basics/basic-lifecycle-stopped.png" /> +<p class="img-caption"><strong>Figura 1.</strong> Quando o usuário sai da atividade, o sistema +chama {@link android.app.Activity#onStop onStop()} para interrompê-la (1). Se o usuário retornar +enquanto a atividade estiver interrompida, o sistema chama {@link android.app.Activity#onRestart onRestart()} +(2), rapidamente seguido por {@link android.app.Activity#onStart onStart()} (3) e {@link +android.app.Activity#onResume()} (4). Observe que independentemente do que tenha causado a interrupção +da atividade, o sistema sempre chama {@link android.app.Activity#onPause onPause()} antes de chamar {@link +android.app.Activity#onStop onStop()}.</p> + + + +<h2 id="Stop">Interromper sua atividade</h2> + +<p>Quando sua atividade recebe uma chamada para o método {@link android.app.Activity#onStop()}, não +está mais visível e deve liberar quase todos os recursos que não foram necessários enquanto o usuário não +estiver utilizando. Quando a atividade for interrompida, o sistema pode destruir a instância se for necessário para +recuperar memória do sistema. Em casos extremos, o sistema pode simplesmente desligar o processo do aplicativo sem +chamar o retorno de chamada{@link android.app.Activity#onDestroy()} final da atividade, portanto, é importante +usar {@link android.app.Activity#onStop()} para liberar recursos que podem vazar memória.</p> + +<p>Embora o método {@link android.app.Activity#onPause onPause()} seja chamado antes de +{@link android.app.Activity#onStop()}, use {@link android.app.Activity#onStop onStop()} +para executar operações de desligamento maiores, que exigem mais da CPU, como escrever informação no +banco de dados.</p> + +<p>Por exemplo, esta é uma implementação de {@link android.app.Activity#onStop onStop()} que +salva os conteúdos de uma nota de rascunho no armazenamento persistente:</p> + +<!-- TODO: Find a better example for onStop, because this kind of thing should probably use a +separate thread but that's too complicated to show here. --> +<pre> +@Override +protected void onStop() { + super.onStop(); // Always call the superclass method first + + // Save the note's current draft, because the activity is stopping + // and we want to be sure the current note progress isn't lost. + ContentValues values = new ContentValues(); + values.put(NotePad.Notes.COLUMN_NAME_NOTE, getCurrentNoteText()); + values.put(NotePad.Notes.COLUMN_NAME_TITLE, getCurrentNoteTitle()); + + getContentResolver().update( + mUri, // The URI for the note to update. + values, // The map of column names and new values to apply to them. + null, // No SELECT criteria are used. + null // No WHERE columns are used. + ); +} +</pre> + +<p>Quando sua atividade é interrompida, o objeto {@link android.app.Activity} é mantido na memória +e é chamado novamente quando a atividade é reiniciada. Não é necessário reiniciar componentes que foram +criados durante qualquer método de retorno de chamada que leve ao estado Reiniciado. O sistema também +tem controle do estado atual de cada {@link android.view.View} no layout. Portanto, se o usuário +inserir um texto em um widget do {@link android.widget.EditText}, o conteúdo será retido e você não +precisará salvar e restaurar.</p> + +<p class="note"><strong>Observação:</strong> mesmo que o sistema destrua sua atividade enquanto estiver interrompida, +ele ainda mantém o estado do objeto {@link android.view.View} (como texto em {@link +android.widget.EditText}) em um {@link android.os.Bundle} (um blob de pares de valores-chave) e os restaura +se o usuário navegar de volta para a mesma instância da atividade (a <a href="recreating.html">próxima lição</a> falará mais sobre uso do {@link android.os.Bundle} para salvar +outros dados do estado caso sua atividade seja destruída e recriada).</p> + + + +<h2 id="Start">Iniciar/reiniciar sua atividade</h2> + +<p>Quando sua atividade voltar ao primeiro plano do estado interrompido, ela recebe uma chamada para +{@link android.app.Activity#onRestart()}. O sistema também chama o método {@link +android.app.Activity#onStart()}, que acontece sempre que a atividade se tornar visível +(ao ser reiniciada ou criada pela primeira vez). No entanto, o método {@link +android.app.Activity#onRestart()} é chamado apenas quando a atividade é reiniciada do +estado interrompido. Portanto, é possível usá-la para executar trabalhos de restauração especiais necessários apenas se +a atividade tiver sido interrompida, mas não destruída.</p> + +<p>Dificilmente um aplicativo precisará usar {@link android.app.Activity#onRestart()} para restaurar +o estado da atividade. Portanto, não há diretrizes para este método que se apliquem à +população geral de aplicativos. Contudo, como espera-se que o método {@link android.app.Activity#onStop()} +limpe todos os recursos da atividade, será necessário instanciá-los +quando a atividade for reiniciada. Ainda assim, será necessário instanciá-los quando a atividade for criada +pela primeira vez (quando não houver instâncias existentes da atividade). Por esse motivo, recomenda-se +utilizar o método de retorno de chamada {@link android.app.Activity#onStart()} como contrapartida +ao método {@link android.app.Activity#onStop()}, porque o sistema chama {@link +android.app.Activity#onStart()} quando cria sua atividade e quando reinicia a +atividade do estado interrompido.</p> + +<p>Por exemplo, como o usuário pode ter ficado longe do aplicativo por um longo período +, o método {@link android.app.Activity#onStart()} é uma boa forma de confirmar se +os recursos do sistema exigidos estão habilitados:</p> + +<pre> +@Override +protected void onStart() { + super.onStart(); // Always call the superclass method first + + // The activity is either being restarted or started for the first time + // so this is where we should make sure that GPS is enabled + LocationManager locationManager = + (LocationManager) getSystemService(Context.LOCATION_SERVICE); + boolean gpsEnabled = locationManager.isProviderEnabled(LocationManager.GPS_PROVIDER); + + if (!gpsEnabled) { + // Create a dialog here that requests the user to enable GPS, and use an intent + // with the android.provider.Settings.ACTION_LOCATION_SOURCE_SETTINGS action + // to take the user to the Settings screen to enable GPS when they click "OK" + } +} + +@Override +protected void onRestart() { + super.onRestart(); // Always call the superclass method first + + // Activity being restarted from stopped state +} +</pre> + + + + +<p>Quando o sistema destrói a atividade, ele chama o método {@link android.app.Activity#onDestroy()} +para seu {@link android.app.Activity}. Como talvez a maior parte de +seus recursos tenha sido liberada com {@link android.app.Activity#onStop()}, no momento em que você receber a chamada para {@link +android.app.Activity#onDestroy()}, não haverá muito a ser feito pelos aplicativos. Esse método é sua +última chance de limpar os recursos que levariam a vazamento de memória. Portanto, certifique-se de que +outros threads sejam destruídos e outras ações de longa execução como o rastreamento de métodos também estejam +interrompidas.</p> + |