Apropriadamente parar ou reiniciar sua ação é um processo importante
dentro da vida útil da ação que assegura que os usuários notem que seu
aplicativo está ativo e não perdeu o progresso. Existem alguns cenários chaves
em que sua ação será parada e reiniciada:
·
O usuário abre a janela Aplicativos Recentes e muda do seu aplicativo
para outro aplicativo, a ação em seu aplicativo está atualmente em primeiro
plano é parada. Se o usuário retornar para sua aplicação pelo ícone de na tela
inicial ou pela janela de Aplicativos Recentes, a ação reinicia.
·
O usuário realiza uma atividade em seu aplicativo que começa uma nova
ação. A ação atual é parada quando a segunda ação é criada. Se o usuário então
pressiona o botão Voltar, a primeira ação é reiniciada.
·
O usuário recebe uma chamada de telefone enquanto usa seu aplicativo.
A classe Ação fornece dois métodos
de vida útil, onStop() e onRestart(), que permitem a você especificamente
manipular como sua ação faz o tratamento para ser parada e reiniciada.
Diferente do estado suspenso, no qual identifica uma obstrução parcial na
interface com o usuário, o estado Parado garante que a interface não está mais
visível e que o foco do usuário está em uma ação separada (ou um aplicativo
totalmente a parte).
Nota: Uma vez que o sistema mantém sua instancia de Ação na memória do
sistema quando este é parado, é impossível que você não precise programar os
métodos onStop() e onRestart() (ou até mesmo onStart()). Para a maioria
das ações que são relativamente simples, a ação irá parar e reiniciar de forma
tão suave como se você usa-se somente onPause() para
suspender as ações atuais e desconecta-las dos recursos do sistema.
 |
| Figura. Quando o usuário deixa a sua ação, o sistema chama onStop() para parar sua ação (1). Se o usuário retornar enquanto a ação está parada, o sistema chama onRestart() (2), rapidamente seguida por onStart() (3) e onResume() (4). Repare que não importa o qual cenário faz a ação parar, o sistema sempre chama onPause() antes de chamar onStop(). |
Parando Sua Ação
Quando sua ação recebe uma chamada para o método onStop() , não está
mais visível e deve liberar a maioria dos recursos dos quais não precisa
enquanto o usuário não está usando. Uma vez que sua ação é parada, o sistema
pode destruir a instancia se precisar recuperar a memória do sistema. Em casos
extremos, o sistema simplesmente mata seu aplicativo sem executar a ação final
com a chamada de onDestroy(), então é importante que você use onStop() para liberar
recursos que gerem um vazamento de memória.
Mesmo que o método onPause() seja chamado
antes de onStop() para realizar
maiores e mais intensivas operações de desligamento no processador, tais como
escritas de informações no banco de dados.
Por exemplo, aqui está uma implementação de onStop() que salva o conteúdo
de uma anotação no armazenamento permanente:
@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.
);
}
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.
);
}
Quando a sua ação é parada, o objeto Ação é mantido
residente na memória e é novamente chamado quando a ação retoma. Você não
precisa reinicializar os componentes que criou durante qualquer chamada de
métodos que o levou ao estado Retomado. O sistema também mantém rastreado o
atual estado para cada View que esteja no
esboço, assim, caso o usuário entre um texto no elemento gráfico EditText, o conteúdo é
mantido e você não precisará salvá-lo para restaurar.
Nota: Mesmo que o sistema destrua a sua ação enquanto é parada, ainda se
mantém no estado do objeto View ( tais como o
texto em EditText) dentro do Bundle (uma quantidade
mínima de valores chaves) e os restaura para que o usuário consiga então
navegar de volta para a mesma instancia da ação (a próxima postagem explicara
mais sobre usar Bundle para salvar o
outro estado dos dados em caso de sua ação ser destruída e recriada).
Iniciar/Reiniciar Sua Ação
Quando sua ação retorna para o primeiro plano de um estado parado, este
recebe a chamada de onRestart(). O sistema chama o método onStart(), que acontece cada vez que sua ação
se torna visível(tendo sido reiniciada ou criada pela primeira vez). O método onRestart(), de qualquer forma, somente é chamado
quando sua ação retoma de um estado parado, portanto você pode usar para
realizar trabalhos de restaurações especiais que podem ser necessários somente
se sua ação foi previamente parada, mas não destruída.
È incomum que seu aplicativo precise usar onRestart() para
restaurar o estado da ação, portanto não existem instruções para este método
que se aplique a população geral dos aplicativos. Entretanto, uma vez que o método onStop()deva ser essencialmente limpo de
todos os recursos da ação, você precisa reinstanciar quando sua atividade
retorna. Ainda, você também precisa instanciar ele quando sua ação for criada
pela primeira vez (quando não existe instancia da ação). Por esta razão, você
deve normalmente usar a chamada de método onStart() como
contraparte para o método onStop(), sendo que o que sistema chama onStart() tanto quando
cria sua ação como quando reinicia sua ação de um estado parado.
Por exemplo, devido ao usuário estar afastado do seu aplicativo por
grande período de tempo antes de retornar, o método onStart() é um bom
lugar para verificar se as características do sistema estejam habilitadas:
@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
}
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
}
Quando o sistema destrói a sua atividade, chama o método onDestroy() para sua Ação. Pela razão de você geralmente
precisar liberar a maioria dos recursos com onStop(), no momento em que você receber a
chamada para onDestroy(), não existe muito do que a maioria
dos aplicativos precise. Este método é sua ultima chance de limpar todos os
recursos para podem levar a um vazamento de memória, então você deve ter
certeza que tarefas adicionais são destruídas e outras longas atividades como o
método para delineamento do esboço são encerrados.
