Cycle de vie de l'activité Android - à quoi servent toutes ces méthodes?

Quel est le cycle de vie d'une activité Androïde? Pourquoi tant de méthodes de sondage similaires ( onCreate() , onStart() , onResume() ) appelé lors de l'initialisation, et tant d'autres ( onPause() , onStop() , onDestroy() ) appelé à la fin?

Quand ces méthodes sont-elles appelées, et comment doivent-ils être utilisés correctement?

378
demandé sur Peter Mortensen 2011-12-15 10:20:44

8 réponses

" Activity Lifecycle (chez Android Developers).

Enter image description here

onCreate() :

appelé lors de la création de l'activité. C'est là que vous devriez faire tous vos réglages statiques habituels: créer des vues, lier des données à des listes, etc. Cette méthode vous fournit également avec un Bundle contenant la l'état gelé de l'activité, s'il y en avait un. Toujours suivi par onStart().

onRestart() :

appelé après que votre activité a été arrêtée, avant qu'elle ne commence encore. Toujours suivi de onStart ()

onStart () :

Appelée lorsque l'activité devient visible pour l'utilisateur. Suivie par onResume () si l'activité vient au premier plan, ou onStop () si elle devient cachée.

onResume() :

appelé lorsque l'activité commencera à interagir avec l'utilisateur. À ce pointez votre activité est en haut de la pile, avec utilisateur d'entrée allant à lui. Toujours suivi de onPause().

onPause () :

appelé dans le cadre du cycle de vie de l'activité quand une activité va dans l'arrière-plan, mais n'a pas (encore) été tué. La contrepartie de onResume (). Lorsque l'activité B est lancée devant l'activité A, ce rappel sera invoqué sur A. B ne sera pas créé jusqu'à ce que a's onPause() retourne, alors assurez-vous de ne pas faites quelque chose de long ici.

onStop() :

Appelé lorsque vous n'êtes plus visible pour l'utilisateur. Vous serez à côté de recevez onRestart(), onDestroy(), ou rien, selon activité utilisateur ultérieure.

notez que cette méthode ne peut jamais être appelée, dans les situations de mémoire faible où le système n'a pas assez de mémoire pour garder votre activité le processus qui s'exécute après sa méthode onPause () est appelé.

onDestroy() :

le dernier appel que vous recevez avant que votre activité ne soit détruite. Ce peut se produire soit parce que l'activité est terminée (quelqu'un appelé finish (), ou parce que le système est temporairement en train de détruire cette exemple de l'activité pour l'enregistrer espace. Vous pouvez distinguer entre> ces deux scénarios avec la méthode isFinishing ().

lorsque L'activité premières charges les événements sont appelés comme ci-dessous:

onCreate()
onStart()
onResume()

quand vous cliquez sur le bouton de téléphone L'activité va à l'arrière-plan et les événements ci-dessous sont appelés:

onPause()
onStop()

Quitter le numéroteur téléphonique et le ci-dessous les événements seront appelés:

onRestart()
onStart()
onResume()

quand vous cliquez sur le bouton arrière ou essayez de terminer () l'activité les événements sont appelés comme ci-dessous:

onPause()
onStop()
onDestroy()

Des États D'Activité

le système D'exploitation Android utilise une file d'attente prioritaire pour aider à gérer les activités exécutées sur l'appareil. Basé sur l'état D'une activité Android particulier est dans, il sera attribué une certaine priorité dans le système D'exploitation. Ce système prioritaire Aide Android à identifier les activités qui ne sont plus utilisées, permettant au système D'exploitation de récupérer de la mémoire et des ressources. Le diagramme suivant illustre les états dans lesquels une activité peut se dérouler pendant sa durée de vie:

Ces états peuvent être divisés en trois groupes principaux comme suit:

Active ou en cours d'Exécution - Les activités sont considérées comme actives ou en cours d'exécution si elles se trouvent au premier plan, aussi appelé le sommet de la pile d'activités. Ceci est considéré comme l'activité la plus prioritaire dans la pile D'activités Android, et en tant que tel ne sera tué par L'OS que dans des situations extrêmes, comme si l'activité essaie d'utiliser plus de mémoire que ce qui est disponible sur l'appareil, car cela pourrait causer L'interface utilisateur de devenir insensible.

arrêt - lorsque l'appareil s'endort, ou un l'activité est encore visible mais partiellement cachée par une nouvelle activité, non-pleine grandeur ou transparente, l'activité est considérée comme étant en pause. Les activités en pause sont toujours vivantes, c'est-à-dire qu'elles conservent toutes les informations sur l'état et les membres et restent rattachées au gestionnaire de fenêtres. Cette activité est considérée comme la deuxième plus grande priorité dans la pile D'activités Android et, en tant que tel, ne sera tué par L'OS si tuer cette activité satisfera les besoins en ressources nécessaires pour garder Activité Active/courante stable et réactive.

arrêté - les activités qui sont complètement obscurcies par une autre activité sont considérées comme étant arrêtées ou à l'arrière-plan. Les activités interrompues tentent toujours de conserver leurs informations sur l'état et les membres aussi longtemps que possible, mais les activités interrompues sont considérées comme la priorité la plus basse des trois états et, à ce titre, L'OS tuera les activités dans cet état en premier lieu pour satisfaire la ressource besoins des activités prioritaires.

*Exemple d'activité pour comprendre le cycle de vie**

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");
    }
}
700
répondu Yaqub Ahmad 2018-07-11 18:07:33

toute la confusion est provoquée puisque Google a choisi des noms Non intuitifs au lieu de quelque chose comme suit:

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] 

le diagramme D'activité peut être interprété comme suit:

enter image description here

145
répondu Nilesh Pawar 2012-03-10 23:22:28

activité a six États

  • Créé
  • a commencé
  • reprise
  • pause
  • arrêté
  • détruit

"1519210920 l'Activité" cycle de vie a sept méthodes

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

activity life cycle

Situations

  • lors de l'ouverture de l'application

    onCreate() --> onStart() -->  onResume()
    
  • lorsque le bouton arrière a appuyé et quitter l'application

    onPaused() -- > onStop() --> onDestory()
    
  • lorsque le bouton d'accueil a appuyé sur

    onPaused() --> onStop()
    
  • après appuyez sur le bouton Accueil lorsque vous ouvrez de nouveau app à partir de la liste des tâches récentes ou cliquez sur l'icône

    onRestart() --> onStart() --> onResume()
    
  • lorsque l'application est ouverte une autre application de la barre de notification ou des paramètres ouverts

    onPaused() --> onStop()
    
  • bouton de retour pressé à partir d'une autre application ou les paramètres utilisés peuvent voir notre application

    onRestart() --> onStart() --> onResume()
    
  • Lorsqu'une boîte de dialogue s'ouvre à l'écran

    onPause()
    
  • après avoir écarté le dialogue ou le bouton arrière de dialogue

    onResume()
    
  • N'importe quel téléphone sonne et l'utilisateur dans l'application

    onPause() --> onResume() 
    
  • lorsque l'Utilisateur a appuyé sur le bouton de réponse du téléphone

    onPause()
    
  • Après la fin d'appel

    onResume()
    
  • Lorsque l'écran du téléphone off

    onPaused() --> onStop()
    
  • lorsque l'écran est retourné sur

    onRestart() --> onStart() --> onResume()
    
137
répondu Arun Kumar 2017-03-24 19:12:19

"ANDROID LIFE-CYCLE

Il ya sept méthodes qui gèrent le cycle de vie d'une application Android:


Réponse pour ce sont toutes ces méthodes pour:

prenons un scénario simple où le savoir dans quel ordre ces méthodes sont appelées nous aidera à donner une clarté pourquoi ils sont utilisés.

  • supposons que vous utilisez une application de calculatrice. Trois méthodes sont appelées à succession pour démarrer l'application.

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

  • quand j'utilise l'application calculatrice, soudain un appel vient le. L'activité de calculatrice va à l'arrière-plan et une autre activité disent. Traiter avec l'appel vient au premier plan, et maintenant deux méthodes être appelé à la succession.

onPause() - - - > onStop()

  • maintenant, dites que je termine la conversation sur le téléphone, la calculatrice l'activité vient au premier plan à partir de l'arrière-plan, donc trois méthodes sont appelés successivement.

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

  • enfin, dire que j'ai terminé toutes les tâches dans calculatrice app, et je souhaitez quitter l'application. Deux autres méthodes sont appelées successivement.

onStop() - - - > onDestroy()


il y a quatre états où une activité peut éventuellement exister:

  • État De Départ
  • État D'Exécution
  • Pause
  • état Arrêté

L'état de départ implique:

créer un nouveau processus Linux, allouer une nouvelle mémoire pour les nouveaux objets UI, et configurer l'écran entier. Donc la plupart du travail est impliqué ici.

L'état courant implique:

C'est l'activité (État) qui est actuellement à l'écran. Cet état seul gère des choses telles que taper sur l'écran, toucher et cliquer des boutons.

L'état en pause implique:

Lorsqu'une activité n'est pas au premier plan et c'est plutôt dans l'arrière-plan, puis l'activité s'est dit en état de pause.

L'état Arrêté implique:

une activité arrêtée ne peut être rachetée au premier plan qu'en la redémarrant et peut aussi être détruite à tout moment.

le Gestionnaire des activités gère tous ces états de manière à ce que: l'expérience utilisateur et la performance est toujours à son meilleur même dans les scénarios où la nouvelle activité est ajoutée aux activités existantes

18
répondu Devrath 2014-09-23 07:37:24

j'aime cette question et ses réponses, mais jusqu'à présent il n'y a pas de couverture des callbacks moins fréquemment utilisés comme onPostCreate () ou onPostResume () . Steve Pomeroy a essayé un diagramme comprenant ces derniers et comment ils se rapportent à Fragment D'Androïde 151940920 "cycle de vie, à https://github.com/xxv/android-lifecycle . J'ai révisé de Steve grand diagramme pour inclure seulement la partie activité et formaté pour la taille de lettre une page d'impression. Je l'ai posté comme un PDF de texte à https://github.com/code-read/android-lifecycle/blob/master/AndroidActivityLifecycle1.pdf et voici son image:

Android Activity Lifecycle

10
répondu CODE-REaD 2016-06-10 16:29:24

de la page des Développeurs Android,

onPause ():

appelé lorsque le système est sur le point de commencer à reprendre une activité précédente. Il est généralement utilisé pour commettre des modifications non enregistrées des données persistantes, arrêtez les animations et autres choses qui peuvent être consommatrices de CPU, etc. Les implémentations de cette méthode doivent être très rapides car la prochaine l'activité ne reprendra pas avant le retour de cette méthode. Suivie par soit onResume() si l'activité revient à l'avant, ou onStop () s'il devient invisible pour l'utilisateur.

onStop ():

Appelée lorsque l'activité n'est plus visible pour l'utilisateur, car une autre activité a repris et couvre celle-ci. Cela peut se produisent soit parce qu'une nouvelle activité est commencée, une activité existante est en face de celui-ci, ou celui-ci est détruit. Suivi par onRestart () si cette activité revient à interagissez avec l'utilisateur, ou onDestroy() si cette activité disparaît.

supposons Maintenant qu'il y a trois Activités et vous aller de A à B, puis onPause sera appelé maintenant de B à C, alors onPause de B et onStop sera appelé.

L'activité en pause obtient un CV et stoppée est redémarrée.

quand vous appelez this.finish() , onPause-onStop-onDestroy être appelé. La principale chose à se rappeler est: les activités en pause sont arrêtés et une activité arrêtée est détruite chaque fois que Android a besoin de mémoire pour d'autres opérations.

j'espère que c'est assez clair.

7
répondu Masiar 2014-01-22 22:21:32

ajout de plus d'informations en plus de la réponse hautement cotée (ajout d'une section supplémentaire de KILLABLE et de la prochaine série de méthodes, qui vont être appelés dans le cycle de vie):

Source: developer.android.com

enter image description here

"Killable " colonne dans le tableau ci-dessus -- pour les méthodes qui sont marquées comme suit: étant killable, après que la méthode retourne le processus hébergeant l'activité peut être tué par le système à tout moment sans qu'une autre ligne de son code soit exécutée.

pour cette raison, vous devriez utiliser la méthode onPause() pour écrire toutes les données persistantes (telles que les modifications de l'utilisateur) au stockage. En outre, la méthode onSaveInstanceState(Bundle) est appelée avant de placer l'activité dans un tel état de fond, vous permettant de sauver n'importe quel état d'instance dynamique dans votre activité dans le donnée Bundle , à recevoir ultérieurement en onCreate(Bundle) si l'activité doit être recréée.

notez qu'il est important de sauvegarder les données persistantes dans onPause() au lieu de onSaveInstanceState(Bundle) parce que ce dernier ne fait pas partie des callbacks du cycle de vie, donc ne sera pas appelé dans toutes les situations décrites dans sa documentation.

je voudrais ajouter quelques méthodes. Ces méthodes ne sont pas listées en tant que méthodes du cycle de vie, mais elles seront appelées cycle de vie selon certaines conditions. Selon votre besoin, vous pourriez avoir à mettre en œuvre ces méthodes dans votre application pour la manipulation appropriée de l'état.

onPostCreate(Bundle savedInstanceState)

S'appelle lorsque le démarrage de l'activité est terminé (après onStart() et onRestoreInstanceState(Bundle) ont été appelés).

onPostResume()

appelé lorsque la reprise de l'activité est terminée (après onResume() appelé).

onSaveInstanceState(Bundle outState)

appelé pour récupérer l'état par instance d'une activité avant d'être tué afin que l'État puisse être restauré dans onCreate(Bundle) ou onRestoreInstanceState(Bundle) (le faisceau peuplé par cette méthode sera passé aux deux).

onRestoreInstanceState(Bundle savedInstanceState)

cette méthode est appelée après onStart() lorsque l'activité est ré-initialisée à partir d'un état précédemment enregistré, donné ici dans savedInstanceState .

mon code d'application en utilisant toutes ces méthodes:

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);
    }
}

Activité De Connexion:

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

sortie: (Avant pause)

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

sortie: (après reprise de pause)

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

notez que onPostResume() est invoquée même si elle n'est pas citée comme méthode du cycle de vie.

1
répondu Ravindra babu 2017-02-11 16:46:08

commençons par les bases j'ai beaucoup de tutoriels sur les composants sensibles au cycle de vie .. vous apprenez pour le cycle de vie que votre question soit https://www.youtube.com/watch?v=e-ews5dRMwI

0
répondu Vishal 2018-06-27 11:10:45