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

420

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?

Nav
fonte
17
Por que essa pergunta foi votada tantas vezes? Por que não foi fechado?
Alexander Kulyakhtin
54
Por que fechar uma pergunta com muitos votos positivos? O Stackoverflow tem um mau hábito disso.
Dick Lucas
12
Esta é uma pergunta no estilo wiki e acho que deveria ser permitida no site.
Mateen Ulhaq
2
@Alexander Kulyakhtin - Por que encerrar esta pergunta? Em vez disso, feche sua conta se não conseguir digerir as informações fornecidas nas respostas para novos usuários do Android. Esta questão está cheia de conhecimento e eu vou votar nessa questão.
Stack Overflow
Para quando esses métodos são chamados de pergunta, o que você tentou?
Sreekanth Karumanaghat

Respostas:

748

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

Digite a descrição da imagem aqui

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");
    }
}
Yaqub Ahmad
fonte
1
Então, se eu entendi corretamente, onStop () é sempre chamado após onPause ()?
Titouan de Bailleul
4
Nem sempre "onStop (): chamado quando você não está mais visível para o usuário"
Yaqub Ahmad 26/26
2
Por acaso, alguma coisa é chamada antes do onCreate?
NodeDad 23/09
6
Sim, existe - o construtor padrão (aquele sem parâmetros). Mas ele tem uso muito limitado para fins de inicialização muito básicos. Normalmente você não deve usá-lo, a menos que saiba realmente o que está fazendo. E mesmo assim, você deve pensar duas vezes se houver uma maneira melhor de fazer as coisas.
Mjoellnir
1
Acho que esse link pode ajudar você a entender melhor o ciclo de vida da atividade. iphtechnologies.com/understanding-lifecycle-in-android-activity
Ashish Kumar Mishra
162

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()

ciclo de vida da atividade

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()
Arun Kumar
fonte
6
'Quando qualquer caixa de diálogo aberta na tela, onPause () é chamada', não é verdadeira para um diálogo de alerta. É chamado apenas quando a caixa de diálogo é uma atividade de diálogo (com o tema definido como @android: style / Theme.Dialog).
Gaurav Jain
2
Resposta valiosa. Envie isso ao google para adicionar à documentação deles. Estou salvando sua resposta em um documento do Word para guardar!
likejudo 11/09/16
Eu não entendo o "Qualquer telefone está tocando e usuário no aplicativo". Qual é o cenário exatamente? Meu primeiro pensamento foi se o usuário estiver no aplicativo e o telefone começar a tocar, então seria onPause () -> onStop () caso a tela inteira se tornasse a chamada. Para a mensagem de chamada heads-up, pode ser apenas OnResume -> onPause (), mas não tenho certeza disso. Qual é a situação em uma chamada para onPause -> onResume? Está no final da ligação?
Sotti 25/10/16
Era isso que eu estava procurando. Só queria saber onde devo colocar minha ligação da API.
Heisenberg
Gostei da sua resposta baseada em cenário .
Kokabi # 5/17
155

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:

insira a descrição da imagem aqui

Nilesh Pawar
fonte
1
Depende. A menos que resolva confusão, um nome longo não será prejudicado. Por exemplo: onRoutePresentationDisplayChanged () é muito mais uma função de dentro SDK Android
Nilesh Pawar
12
Pessoalmente, não acho seus nomes extremamente mais intuitivos, além de Fragmentos, eles realmente não se correlacionam.
Martin Marconcini
9
Votado. Mais útil que a documentação oficial
bad_keypoints 03/03
3
É um ótimo post. Um problema. Quando você digita os métodos Andoid Lifecycle no google, essa imagem aparece acima da opção de pesquisa (nem mesmo no modo de pesquisa de imagens) como resposta aos métodos de ciclo de vida do Android. O inconsciente (ou preguiçoso, dependendo de como você o vê) pode ser facilmente enganado, a menos que siga o link StackOverflow em vez de clicar na imagem do fluxograma (sua imagem).
Andrew S
1
Sim. É isso que eu tenho procurado. Alguém deve escrever um livro (ou um documento?) Com coisas assim. onResume etc. não fazem sentido.
30518 Harsha_K
22

CICLO DE VIDA ANDROID

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


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

Devrath
fonte
algum exemplo de onPause para onResume ?
zeeali
14

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:

Ciclo de vida da atividade do Android

COD-REaD
fonte
8

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.

Masiar
fonte
podemos chamar o método onPause como um estágio intermediário entre a atividade que começa a perder o foco e finalmente se tornar invisível para o usuário e o método Onstop como quando a atividade se tornou completamente invisível para o usuário?
Nav
Eu acho que deveria ser assim.
Masiar
3
@Nav Suponha que existam 3 atividades e você vá de A para B, a onPause de A será chamada agora de B para C e a onPause de B e onStop de A serão chamadas.
MKJParekh
3

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

insira a descrição da imagem aqui

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.

Ravindra babu
fonte
0

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).

Fogo de dragão
fonte