Cycle de vie des activités Android - à quoi servent toutes ces méthodes?

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

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

Voyez-le dans Activity Lifecycle (chez les développeurs Android).

onCreate () :

Appelé lorsque l'activité est créée pour la première fois. C'est là que vous devez effectuer toute votre configuration statique normale: créer des vues, lier des données à des listes, etc. Cette méthode vous fournit également un Bundle contenant l'état précédemment gelé de l'activité, s'il y en avait un. Toujours suivi de onStart ().

onRestart () :

Appelé après l'arrêt de votre activité, avant son redémarrage. Toujours suivi par onStart ()

onStart () :

Appelé lorsque l'activité devient visible pour l'utilisateur. Suivi de onResume () si l'activité vient au premier plan.

pour résumer() :

Appelé lorsque l'activité commencera à interagir avec l'utilisateur. À ce stade, votre activité se trouve en haut de la pile d'activités, avec la contribution de l'utilisateur. Toujours suivi de onPause ().

onPause () :

Appelé dans le cadre du cycle de vie d'une activité lorsqu'une activité passe en arrière-plan, mais n'a pas (encore) été supprimée. L'homologue de onResume (). Lorsque l'activité B est lancée devant l'activité A, ce rappel sera invoqué sur A. B ne sera pas créé avant le retour de A onPause (), alors assurez-vous de ne rien faire de long ici.

onStop () :

Appelé lorsque l'utilisateur n'est plus visible. Vous recevrez ensuite soit onRestart (), onDestroy (), soit rien, selon l'activité ultérieure de l'utilisateur. Notez que cette méthode peut ne jamais être appelée, dans des situations de faible mémoire où le système n'a pas assez de mémoire pour maintenir le processus de votre activité en cours après l'appel de sa méthode onPause ().

onDestroy () :

Le dernier appel que vous recevez avant que votre activité ne soit détruite. Cela peut se produire soit parce que l'activité est en train de se terminer (quelqu'un appelé finish (), soit parce que le système détruit temporairement cette instance de l'activité pour économiser de l'espace. Vous pouvez distinguer> ces deux scénarios avec la méthode isFinishing ().

Lors du premier chargement de l'activité, les événements sont appelés comme suit:

onCreate()
onStart()
onResume()

Lorsque vous cliquez sur le bouton Téléphone, l'activité passe en arrière-plan et les événements ci-dessous sont appelés:

onPause()
onStop()

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

onRestart()
onStart()
onResume()

Lorsque vous cliquez sur le bouton Précédent OU essayez de terminer () l'activité, les événements sont appelés comme suit:

onPause()
onStop()
onDestroy()

États d'activité

Le système d'exploitation Android utilise une file d'attente prioritaire pour vous aider à gérer les activités en cours d'exécution sur l'appareil. En fonction de l'état dans lequel se trouve une activité Android particulière, une certaine priorité lui sera attribuée dans le système d'exploitation. Ce système de priorité 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 qu'une activité peut traverser pendant sa durée de vie:

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

Actif ou en cours d'exécution - Les activités sont considérées comme actives ou en cours d'exécution si elles sont au premier plan, également appelées haut 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, il ne sera tué par le système d'exploitation que dans des situations extrêmes, comme si l'activité essaie d'utiliser plus de mémoire que celle disponible sur l'appareil, car cela pourrait entraîner la perte de l'interface utilisateur. devenir insensible.

En pause - Lorsque l'appareil se met en veille ou lorsqu'une activité est encore visible mais partiellement masquée par une nouvelle activité, non pleine grandeur ou transparente, l'activité est considérée comme interrompue. Les activités suspendues sont toujours actives, c'est-à-dire qu'elles conservent toutes les informations d'état et de membre et restent attachées au gestionnaire de fenêtres. Ceci est considéré comme la deuxième activité de priorité la plus élevée dans la pile d'activités Android et, en tant que tel, ne sera tué par le système d'exploitation que si la suppression de cette activité satisfait aux exigences en ressources nécessaires pour maintenir l'activité active / en cours d'exécution stable et réactive.

Arrêté - Les activités qui sont complètement masquées par une autre activité sont considérées comme arrêtées ou en arrière-plan. Les activités arrêtées tentent toujours de conserver leurs informations d'état et de membre aussi longtemps que possible, mais les activités arrêtées sont considérées comme la priorité la plus basse des trois États et, en tant que tel, le système d'exploitation supprimera les activités dans cet état en premier pour satisfaire les besoins en ressources d'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");
    }
}

L'activité a six états

• Créé
• Commencé
• A repris
• En pause
• Arrêté
• Détruit

Le cycle de vie des activités comprend sept méthodes

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

Situations

• Lorsque vous ouvrez l'application

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

• Lorsque vous appuyez sur le bouton de retour et quittez l'application

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

• Lorsque le bouton d'accueil est enfoncé

  onPaused() --> onStop()

• Après avoir appuyé sur le bouton d'accueil, ouvrez à nouveau l'application à partir de la liste des tâches récentes ou cliquez sur l'icône

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

• Lorsque vous ouvrez une autre application depuis la barre de notification ou ouvrez les paramètres

  onPaused() --> onStop()

• Appuyez sur le bouton Retour à partir d'une autre application ou des paramètres utilisés pour voir notre application

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

• Lorsqu'une boîte de dialogue s'ouvre à l'écran

  onPause()

• Après avoir fermé la boîte de dialogue ou le bouton de retour de la boîte de dialogue

  onResume()

• Tout 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 de l'appel

  onResume()

• Lorsque l'écran du téléphone est éteint

  onPaused() --> onStop()

• Lorsque l'écran est rallumé

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

La confusion est due au fait que 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:

CYCLE DE VIE ANDROID

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

• onCreate ()
• onStart ()
• pour résumer()
• onRestart ()
• onPause ()
• onStop ()
• onDestroy ()

Répondez à quelles sont toutes ces méthodes pour:

Prenons un scénario simple où savoir dans quel ordre ces méthodes sont appelées nous aidera à clarifier pourquoi elles sont utilisées.

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

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

• Lorsque j'utilise l'application calculatrice, un appel arrive soudainement. L'activité de la calculatrice passe à l'arrière-plan et une autre activité dit. Le traitement de l'appel vient au premier plan et maintenant deux méthodes sont appelées successivement.

onPause() - - -> onStop()

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

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

• Enfin, disons que j'ai terminé toutes les tâches de l'application calculatrice et que je souhaite quitter l'application. Deux autres méthodes sont appelées successivement.

onStop() - - -> onDestroy()

Il existe quatre états dans lesquels une activité peut éventuellement exister:

• État de départ
• État de fonctionnement
• État suspendu
• État arrêté

L'état de départ implique:

Création d'un nouveau processus Linux, allocation de nouvelle mémoire pour les nouveaux objets d'interface utilisateur et configuration de tout l'écran. Donc, la plupart du travail est impliqué ici.

L'état de fonctionnement implique:

C'est l'activité (état) qui est actuellement à l'écran. Cet état gère à lui seul des choses telles que la saisie à l'écran et le toucher et le clic sur les boutons.

Un état suspendu implique:

Lorsqu'une activité n'est pas au premier plan et à la place elle est en arrière-plan, alors l'activité est dite en pause.

L'état arrêté implique:

Une activité arrêtée ne peut être achetée au premier plan qu'en la redémarrant et elle peut également être détruite à tout moment.

Le gestionnaire d'activités gère tous ces états de manière à ce que l'expérience utilisateur et les performances soient toujours à leur meilleur, même dans les scénarios où la nouvelle activité est ajoutée aux activités existantes.

J'aime cette question et ses réponses, mais jusqu'à présent, il n'y a pas de couverture des rappels moins fréquemment utilisés comme onPostCreate () ou onPostResume () . Steve Pomeroy a tenté un diagramme incluant ces derniers et comment ils se rapportent au cycle de vie des fragments d'Android , à https://github.com/xxv/android-lifecycle . J'ai révisé le grand diagramme de Steve pour inclure uniquement la partie Activité et je l'ai formaté pour une impression d'une page de format lettre. Je l'ai posté sous forme de texte PDF à https://github.com/code-read/android-lifecycle/blob/master/AndroidActivityLifecycle1.pdf et ci-dessous est son image:

Sur la page Développeurs Android,

onPause ():

Appelé lorsque le système est sur le point de reprendre une activité précédente. Ceci est généralement utilisé pour valider les modifications non enregistrées des données persistantes, arrêter les animations et autres choses qui peuvent consommer du processeur, etc. Les implémentations de cette méthode doivent être très rapides car l'activité suivante ne reprendra qu'au retour de cette méthode. Suivi de onResume () si l'activité revient à l'avant ou onStop () si elle devient invisible pour l'utilisateur.

onStop ():

Appelé lorsque l'activité n'est plus visible par l'utilisateur, car une autre activité a repris et couvre celle-ci. Cela peut se produire soit parce qu'une nouvelle activité est en cours de lancement, une activité existante est amenée devant celle-ci, soit celle-ci est détruite. Suivi de onRestart () si cette activité revient pour interagir avec l'utilisateur, ou onDestroy () si cette activité disparaît.

Supposons maintenant qu'il y a trois activités et que vous passez de A à B, puis onPause de A sera appelé maintenant de B à C, puis onPause de B et onStop of A sera appelé.

L'activité suspendue obtient un CV et arrêtée est redémarrée.

Lorsque vous appelez this.finish(), onPause-onStop-onDestroy sera appelé. La principale chose à retenir est la suivante: les activités en pause sont arrêtées et une activité arrêtée est détruite chaque fois qu'Android a besoin de mémoire pour d'autres opérations.

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

Ajout de plus d'informations en plus de la réponse la mieux notée (Ajout d'une section supplémentaire de KILLABLE et du prochain ensemble de méthodes, qui seront appelées dans le cycle de vie):

Source: developer.android.com

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

Pour cette raison, vous devez utiliser la onPause()méthode pour écrire toutes les données persistantes (telles que les modifications utilisateur) dans le stockage. De plus, la méthode onSaveInstanceState(Bundle)est appelée avant de placer l'activité dans un tel état d'arrière-plan, ce qui vous permet d'enregistrer tout état d'instance dynamique dans votre activité dans le donné Bundle, pour être reçu ultérieurement onCreate(Bundle)si l'activité doit être recréée.

Notez qu'il est important d'enregistrer les données persistantes au onPause()lieu de onSaveInstanceState(Bundle)car ces dernières ne font pas partie des rappels du cycle de vie, elles ne seront donc pas appelées dans toutes les situations comme décrit dans sa documentation.

Je voudrais ajouter quelques méthodes supplémentaires. Celles-ci ne sont pas répertoriées comme méthodes de cycle de vie, mais elles seront appelées pendant le cycle de vie en fonction de certaines conditions. Selon vos besoins, vous devrez peut-être implémenter ces méthodes dans votre application pour une gestion appropriée de l'état.

onPostCreate(Bundle savedInstanceState)

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

onPostResume()

Appelé lorsque la reprise d'activité est terminée (après onResume()avoir été 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 bundle rempli par cette méthode sera transmis 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é, indiqué 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 la pause)

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

Notez que cela onPostResume()est invoqué même s'il n'est pas cité comme méthode du cycle de vie.

Je lance quelques journaux selon les réponses ci-dessus et voici la sortie:

Activité de démarrage

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: 

Arrêt de l'activité

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: 

À mon avis personnel, seulement deux sont nécessaires sur Start et onStop.

onResume semble être dans chaque cas de retour, et onPause dans chaque cas de départ (sauf pour fermer l'application).