Ciclo de vida da atividade do Android - para que servem todos esses métodos?

Qual é o ciclo de vida de uma atividade Android? Por que tantos métodos de som semelhante ( onCreate(), onStart(), onResume()) chamada durante a inicialização, e tantos outros ( onPause(), onStop(), onDestroy()) chamado no final?

Quando esses métodos são chamados e como devem ser usados ​​corretamente?

Veja-o no Ciclo de Vida da Atividade (em Desenvolvedores Android).

onCreate () :

Chamado quando a atividade é criada pela primeira vez. É aqui que você deve fazer toda a sua configuração estática normal: criar visualizações, vincular dados a listas etc. Este método também fornece um Bundle que contém o estado congelado anteriormente da atividade, se houver. Sempre seguido por onStart ().

onRestart () :

Chamado depois que sua atividade foi interrompida, antes de ser reiniciada. Sempre seguido por onStart ()

onStart () :

Chamado quando a atividade está se tornando visível para o usuário. Seguido por onResume () se a atividade vier para o primeiro plano.

onResume () :

Chamado quando a atividade começará a interagir com o usuário. Nesse ponto, sua atividade está no topo da pilha de atividades, com a entrada do usuário. Sempre seguido por onPause ().

onPause () :

Chamado como parte do ciclo de vida da atividade quando uma atividade está em segundo plano, mas ainda não foi eliminada. A contraparte de onResume (). Quando a atividade B é iniciada na frente da atividade A, esse retorno de chamada será invocado em A. B não será criado até que a onPause (A) retorne, portanto, não faça nada longo aqui.

onStop () :

Chamado quando você não estiver mais visível para o usuário. Em seguida, você receberá onRestart (), onDestroy () ou nada, dependendo da atividade posterior do usuário. Observe que esse método nunca pode ser chamado, em situações de pouca memória em que o sistema não possui memória suficiente para manter o processo de sua atividade em execução após a chamada do método onPause ().

onDestroy () :

A chamada final que você recebe antes que sua atividade seja destruída. Isso pode acontecer porque a atividade está terminando (alguém chamado finish () nela, ou porque o sistema está destruindo temporariamente esta instância da atividade para economizar espaço. Você pode distinguir entre esses dois cenários com o método isFinishing ().

Quando a atividade é carregada pela primeira vez, os eventos são chamados como abaixo:

onCreate()
onStart()
onResume()

Quando você clica no botão Telefone, a Atividade fica em segundo plano e os eventos abaixo são chamados:

onPause()
onStop()

Saia do discador do telefone e os eventos abaixo serão chamados:

onRestart()
onStart()
onResume()

Quando você clica no botão voltar OU tenta terminar () a atividade que os eventos são chamados como abaixo:

onPause()
onStop()
onDestroy()

Estados de atividade

O sistema operacional Android usa uma fila de prioridade para ajudar no gerenciamento de atividades em execução no dispositivo. Com base no estado em que uma atividade específica do Android está, será atribuída uma certa prioridade no sistema operacional. Esse sistema prioritário ajuda o Android a identificar atividades que não estão mais em uso, permitindo que o sistema operacional recupere memória e recursos. O diagrama a seguir ilustra os estados pelos quais uma atividade pode passar durante sua vida útil:

Esses estados podem ser divididos em três grupos principais, da seguinte maneira:

Ativo ou em execução - as atividades são consideradas ativas ou em execução se estiverem em primeiro plano, também conhecidas como a parte superior da pilha de atividades. Essa é considerada a atividade de maior prioridade na pilha de atividades do Android e, como tal, só será eliminada pelo sistema operacional em situações extremas, como se a atividade tentar usar mais memória do que a disponível no dispositivo, pois isso pode fazer com que a interface do usuário deixar de responder.

Pausado - Quando o dispositivo entra no modo de suspensão ou uma atividade ainda é visível, mas parcialmente oculta por uma atividade nova, sem tamanho ou transparente, a atividade é considerada pausada. As atividades em pausa ainda estão ativas, ou seja, elas mantêm todas as informações de estado e membro e permanecem anexadas ao gerenciador de janelas. Essa é considerada a segunda atividade de maior prioridade na pilha de atividades do Android e, como tal, só será eliminada pelo sistema operacional se a eliminação dessa atividade atender aos requisitos de recursos necessários para manter a atividade ativa / em execução estável e responsiva.

Parado - As atividades que são completamente obscurecidas por outra atividade são consideradas paradas ou em segundo plano. As atividades interrompidas ainda tentam reter suas informações sobre o estado e os membros pelo maior tempo possível, mas as atividades interrompidas são consideradas a prioridade mais baixa dos três estados e, como tal, o sistema operacional eliminará as atividades nesse estado primeiro para atender aos requisitos de recursos de atividades de maior prioridade.

* Exemplo de atividade para entender o ciclo de vida **

import android.app.Activity;
import android.os.Bundle;
import android.util.Log;
public class MainActivity extends Activity {
    String tag = "LifeCycleEvents";
    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
       super.onCreate(savedInstanceState);
       setContentView(R.layout.main);
       Log.d(tag, "In the onCreate() event");
    }
    public void onStart()
    {
       super.onStart();
       Log.d(tag, "In the onStart() event");
    }
    public void onRestart()
    {
       super.onRestart();
       Log.d(tag, "In the onRestart() event");
    }
    public void onResume()
    {
       super.onResume();
       Log.d(tag, "In the onResume() event");
    }
    public void onPause()
    {
       super.onPause();
       Log.d(tag, "In the onPause() event");
    }
    public void onStop()
    {
       super.onStop();
       Log.d(tag, "In the onStop() event");
    }
    public void onDestroy()
    {
       super.onDestroy();
       Log.d(tag, "In the onDestroy() event");
    }
}

Atividade tem seis estados

• Criada
• Começado
• Retomado
• Pausado
• Parado
• Destruído

O ciclo de vida da atividade possui sete métodos

• onCreate()
• onStart()
• onResume()
• onPause()
• onStop()
• onRestart()
• onDestroy()

Situações

• Quando abrir o aplicativo

  onCreate() --> onStart() -->  onResume()

• Quando o botão voltar pressionado e sair do aplicativo

  onPaused() -- > onStop() --> onDestory()

• Quando o botão home é pressionado

  onPaused() --> onStop()

• Depois de pressionar o botão home, quando abrir novamente o aplicativo da lista de tarefas recente ou clicar no ícone

  onRestart() --> onStart() --> onResume()

• Ao abrir um aplicativo, outro aplicativo na barra de notificação ou nas configurações abertas

  onPaused() --> onStop()

• O botão Voltar pressionado em outro aplicativo ou nas configurações usadas pode ver nosso aplicativo

  onRestart() --> onStart() --> onResume()

• Quando qualquer caixa de diálogo é aberta na tela

  onPause()

• Depois de descartar a caixa de diálogo ou o botão voltar da caixa de diálogo

  onResume()

• Qualquer telefone está tocando e o usuário no aplicativo

  onPause() --> onResume() 

• Quando o usuário pressionou o botão de atendimento do telefone

  onPause()

• Após o término da chamada

  onResume()

• Quando a tela do telefone está desligada

  onPaused() --> onStop()

• Quando a tela é ligada novamente

  onRestart() --> onStart() --> onResume()

Toda a confusão é causada, já que o Google escolheu nomes não-intuitivos em vez de algo como a seguir:

onCreateAndPrepareToDisplay()   [instead of onCreate() ]
onPrepareToDisplay()            [instead of onRestart() ]
onVisible()                     [instead of onStart() ]
onBeginInteraction()            [instead of onResume() ]
onPauseInteraction()            [instead of onPause() ]
onInvisible()                   [instead of onStop]
onDestroy()                     [no change] 

O diagrama de atividades pode ser interpretado como:

CICLO DE VIDA ANDROID

Existem sete métodos que gerenciam o ciclo de vida de um aplicativo Android:

• onCreate ()
• onStart ()
• Resumindo()
• onRestart ()
• onPause ()
• onStop ()
• onDestroy ()

Responda para que servem todos esses métodos:

Vamos tomar um cenário simples em que saber em que ordem esses métodos são chamados nos ajudará a esclarecer por que eles são usados.

• Suponha que você esteja usando um aplicativo de calculadora. Três métodos são chamados em sucessão para iniciar o aplicativo.

onCreate() - - -> - - ->onStart() onResume()

• Quando estou usando o aplicativo da calculadora, de repente chega uma chamada. A atividade da calculadora vai para segundo plano e outra atividade diz. Lidar com a chamada chega ao primeiro plano e agora dois métodos são chamados em sucessão.

onPause() - - -> onStop()

• Agora, digamos que eu termine a conversa por telefone, a atividade da calculadora vem de primeiro plano do fundo, portanto, três métodos são chamados em sucessão.

onRestart() - - -> - - ->onStart() onResume()

• Por fim, digamos que terminei todas as tarefas no aplicativo calculadora e desejo sair do aplicativo. Outros dois métodos são chamados em sucessão.

onStop() - - -> onDestroy()

Existem quatro estados nos quais uma atividade pode existir:

• Estado inicial
• Estado em Execução
• Estado em pausa
• Estado parado

O estado inicial envolve:

Criando um novo processo Linux, alocando nova memória para os novos objetos de interface do usuário e configurando a tela inteira. Portanto, a maior parte do trabalho está envolvida aqui.

O estado de execução envolve:

É a atividade (estado) que está atualmente na tela. Somente esse estado lida com coisas como digitar na tela e tocar e clicar nos botões.

O estado de pausa envolve:

Quando uma atividade não está em primeiro plano e, em vez disso, está em segundo plano, diz-se que a atividade está no estado de pausa.

O estado parado envolve:

Uma atividade parada só pode ser comprada em primeiro plano reiniciando-a e também pode ser destruída a qualquer momento.

O gerenciador de atividades lida com todos esses estados de forma que a experiência e o desempenho do usuário sejam sempre os melhores, mesmo em cenários em que a nova atividade é adicionada às atividades existentes

Gosto dessa pergunta e das respostas, mas até agora não há cobertura de retornos de chamada usados ​​com menos frequência, como onPostCreate () ou onPostResume () . Steve Pomeroy tentou um diagrama incluindo estes e como se relacionam com o Android Fragmento ciclo de vida, em https://github.com/xxv/android-lifecycle . Revisei o diagrama grande de Steve para incluir apenas a parte Activity e o formatou para impressão de uma página em tamanho carta. Eu o publiquei como um PDF de texto em https://github.com/code-read/android-lifecycle/blob/master/AndroidActivityLifecycle1.pdf e abaixo é a sua imagem:

Na página Desenvolvedores Android,

onPause ():

Chamado quando o sistema está prestes a começar a retomar uma atividade anterior. Isso geralmente é usado para confirmar alterações não salvas em dados persistentes, interromper animações e outras coisas que possam estar consumindo CPU, etc. As implementações desse método devem ser muito rápidas, porque a próxima atividade não será retomada até que esse método retorne. Seguido por onResume () se a atividade retornar para a frente ou onStop () se ficar invisível para o usuário.

onStop ():

Chamado quando a atividade não está mais visível para o usuário, porque outra atividade foi retomada e está cobrindo esta. Isso pode acontecer porque uma nova atividade está sendo iniciada, uma já existente está sendo trazida para a frente ou outra está sendo destruída. Seguido por onRestart () se esta atividade está voltando para interagir com o usuário, ou onDestroy () se esta atividade estiver desaparecendo.

Agora, suponha que existam três atividades e você vá de A para B, a onPause de A será chamada agora de B para C, a onPause de B e a onStop de A serão chamadas.

A Atividade pausada obtém um resumo e Parado é reiniciado.

Quando você ligar this.finish(), onPause-onStop-onDestroy será chamado. O principal a lembrar é: as atividades pausadas são interrompidas e uma atividade interrompida é destruída sempre que o Android exigir memória para outras operações.

Espero que esteja claro o suficiente.

Adicionando mais algumas informações sobre as respostas altamente classificadas (seção adicional adicionada de KILLABLE e próximo conjunto de métodos, que serão chamados no ciclo de vida):

Fonte: developer.android.com

Observe a coluna " Matável " na tabela acima - para os métodos marcados como matáveis, após o retorno desse método, o processo que hospeda a atividade pode ser eliminado pelo sistema a qualquer momento, sem que outra linha de seu código seja executada.

Por esse motivo, você deve usar o onPause()método para gravar quaisquer dados persistentes (como edições do usuário) no armazenamento. Além disso, o método onSaveInstanceState(Bundle)é chamado antes de colocar a atividade em um estado de segundo plano, permitindo salvar qualquer estado dinâmico da instância em sua atividade no dado Bundle, para ser recebido posteriormente onCreate(Bundle)se a atividade precisar ser recriada.

Observe que é importante salvar dados persistentes em onPause()vez de, onSaveInstanceState(Bundle)porque estes não fazem parte dos retornos de chamada do ciclo de vida, portanto, não serão chamados em todas as situações, conforme descrito em sua documentação.

Eu gostaria de adicionar mais alguns métodos. Eles não são listados como métodos de ciclo de vida, mas serão chamados durante o ciclo de vida, dependendo de algumas condições. Dependendo do seu requisito, pode ser necessário implementar esses métodos em seu aplicativo para o manuseio adequado do estado.

onPostCreate(Bundle savedInstanceState)

Chamado quando a inicialização da atividade é concluída (depois onStart()e onRestoreInstanceState(Bundle)foi chamada).

onPostResume()

Chamado quando o resumo da atividade estiver concluído (depois de onResume()ter sido chamado).

onSaveInstanceState(Bundle outState)

Chamado para recuperar o estado por instância de uma atividade antes de ser eliminado, para que o estado possa ser restaurado em onCreate(Bundle)ou onRestoreInstanceState(Bundle)(o Bundle preenchido por esse método será passado para ambos).

onRestoreInstanceState(Bundle savedInstanceState)

Esse método é chamado depois onStart()que a atividade está sendo reinicializada a partir de um estado salvo anteriormente, fornecido aqui em savedInstanceState.

Meu código de aplicativo usando todos esses métodos:

public class MainActivity extends AppCompatActivity implements View.OnClickListener{

    private EditText txtUserName;
    private EditText txtPassword;
    Button  loginButton;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        Log.d("Ravi","Main OnCreate");
        txtUserName=(EditText) findViewById(R.id.username);
        txtPassword=(EditText) findViewById(R.id.password);
        loginButton =  (Button)  findViewById(R.id.login);
        loginButton.setOnClickListener(this);

    }

    @Override
    public void onClick(View view) {
        Log.d("Ravi", "Login processing initiated");
        Intent intent = new Intent(this,LoginActivity.class);
        Bundle bundle = new Bundle();
        bundle.putString("userName",txtUserName.getText().toString());
        bundle.putString("password",txtPassword.getText().toString());
        intent.putExtras(bundle);
        startActivityForResult(intent,1);
       // IntentFilter
    }
    public void onActivityResult(int requestCode, int resultCode, Intent resIntent){
        Log.d("Ravi back result:", "start");
        String result = resIntent.getStringExtra("result");
        Log.d("Ravi back result:", result);
        TextView txtView = (TextView)findViewById(R.id.txtView);
        txtView.setText(result);

        Intent sendIntent = new Intent();
        //sendIntent.setPackage("com.whatsapp");
        sendIntent.setAction(Intent.ACTION_SEND);
        sendIntent.putExtra(Intent.EXTRA_TEXT, "Message...");
        sendIntent.setType("text/plain");
        startActivity(sendIntent);
    }

    @Override
    protected void onStart() {
        super.onStart();
        Log.d("Ravi","Main Start");
    }

    @Override
    protected void onRestart() {
        super.onRestart();
        Log.d("Ravi","Main ReStart");
    }

    @Override
    protected void onPause() {
        super.onPause();
        Log.d("Ravi","Main Pause");
    }

    @Override
    protected void onResume() {
        super.onResume();
        Log.d("Ravi","Main Resume");
    }

    @Override
    protected void onStop() {
        super.onStop();
        Log.d("Ravi","Main Stop");
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        Log.d("Ravi","Main OnDestroy");
    }

    @Override
    public void onPostCreate(Bundle savedInstanceState, PersistableBundle persistentState) {
        super.onPostCreate(savedInstanceState, persistentState);
        Log.d("Ravi","Main onPostCreate");
    }

    @Override
    protected void onPostResume() {
        super.onPostResume();
        Log.d("Ravi","Main PostResume");
    }

    @Override
    public void onSaveInstanceState(Bundle outState, PersistableBundle outPersistentState) {
        super.onSaveInstanceState(outState, outPersistentState);
    }

    @Override
    protected void onRestoreInstanceState(Bundle savedInstanceState) {
        super.onRestoreInstanceState(savedInstanceState);
    }
}

Atividade de login:

public class LoginActivity extends AppCompatActivity {

    private TextView txtView;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_login);
        txtView = (TextView) findViewById(R.id.Result);
        Log.d("Ravi","Login OnCreate");
        Bundle bundle = getIntent().getExtras();
        txtView.setText(bundle.getString("userName")+":"+bundle.getString("password"));
        //Intent  intent = new Intent(this,MainActivity.class);
        Intent  intent = new Intent();
        intent.putExtra("result","Success");
        setResult(1,intent);
       // finish();
    }
}

saída: (Antes da pausa)

D/Ravi: Main OnCreate
D/Ravi: Main Start
D/Ravi: Main Resume
D/Ravi: Main PostResume

saída: (Após retomar da pausa)

D/Ravi: Main ReStart
D/Ravi: Main Start
D/Ravi: Main Resume
D/Ravi: Main PostResume

Observe que onPostResume()é chamado mesmo que não seja citado como método de ciclo de vida.

Eu corro alguns logs como por respostas acima e aqui está a saída:

Atividade inicial

On Activity Load (First Time)
————————————————————————————————————————————————
D/IndividualChatActivity: onCreate: 
D/IndividualChatActivity: onStart: 
D/IndividualChatActivity: onResume: 
D/IndividualChatActivity: onPostResume: 

Reload After BackPressed
————————————————————————————————————————————————
D/IndividualChatActivity: onCreate: 
D/IndividualChatActivity: onStart: 
D/IndividualChatActivity: onResume: 
D/IndividualChatActivity: onPostResume: 

OnMaximize(Circle Button)
————————————————————————————————————————————————
D/IndividualChatActivity: onRestart: 
D/IndividualChatActivity: onStart: 
D/IndividualChatActivity: onResume: 
D/IndividualChatActivity: onPostResume: 

OnMaximize(Square Button)
————————————————————————————————————————————————
D/IndividualChatActivity: onRestart: 
D/IndividualChatActivity: onStart: 
D/IndividualChatActivity: onResume: 
D/IndividualChatActivity: onPostResume: 

Parando a atividade

On BackPressed
————————————————————————————————————————————————
D/IndividualChatActivity: onPause:
D/IndividualChatActivity: onStop: 
D/IndividualChatActivity: onDestroy: 

OnMinimize (Circle Button)
————————————————————————————————————————————————
D/IndividualChatActivity: onPause: 
D/IndividualChatActivity: onStop: 

OnMinimize (Square Button)
————————————————————————————————————————————————
D/IndividualChatActivity: onPause: 
D/IndividualChatActivity: onStop: 

Going To Another Activity
————————————————————————————————————————————————
D/IndividualChatActivity: onPause:
D/IndividualChatActivity: onStop: 

Close The App
————————————————————————————————————————————————
D/IndividualChatActivity: onDestroy: 

Na minha opinião pessoal, apenas dois são necessários onStart e onStop.

onResume parece estar em todos os casos de retorno e onPause em todos os casos de saída (exceto para o fechamento do aplicativo).