Android cycle de vie des activités - à quoi servent toutes ces méthodes?
Quel est le cycle de vie d'une activité Android? Pourquoi autant de méthodes de sondage similaires (onCreate(), onStart(), onResume()) sont-elles appelées 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-elles être utilisées correctement?
Voir dans cycle de vie de l'activité (sous Android développeurs).
Appelé lorsque l'activité est créée pour la première fois. C’est ici 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é, le cas échéant. Toujours suivi de onStart ().
Appelé après l’arrêt de votre activité, avant son redémarrage. Toujours suivi de onStart ()
Appelé lorsque l'activité devient visible pour l'utilisateur. Suivi par onResume () si l'activité passe au premier plan.
Appelé lorsque l'activité commencera à interagir avec l'utilisateur. À ce stade, votre activité se situe au sommet de la pile d’activités, avec la saisie de l’utilisateur. Toujours suivi de onPause ().
Appelée dans le cadre du cycle de vie d'une activité lorsqu'une activité passe en arrière-plan, mais qu'elle n'a pas (encore) été supprimée. La contrepartie de onResume (). Lorsque l'activité B est lancée devant l'activité A, ce rappel est appelé sur A. B ne sera pas créé avant le retour de A onPause (). Veillez donc à ne rien faire de long ici.
Appelé lorsque vous n'êtes plus visible par l'utilisateur. Vous recevrez ensuite onRestart (), onDestroy () ou rien, selon l'activité de l'utilisateur. Notez que cette méthode peut ne jamais être appelée, dans les situations de mémoire insuffisante, où le système ne dispose pas de suffisamment de mémoire pour que le processus de votre activité continue de s'exécuter après l'appel de sa méthode onPause ().
Le dernier appel que vous recevez avant que votre activité soit détruite. Cela peut se produire soit parce que l'activité se termine (quelqu'un qui s'appelle finish () dessus, soit parce que le système est en train de détruire temporairement cette instance de l'activité pour économiser de l'espace.> Vous pouvez faire la distinction entre ces deux scénarios avec la méthode isFinishing ().
Lorsque l'activité est chargée pour la première fois , les événements sont appelés comme suit:
onCreate()
onStart()
onResume()
Lorsque vous cliquez sur le bouton Téléphone , l'activité passe à l'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 retour OR essayez de terminer () l'activité des événements est appelée comme ci-dessous:
onPause()
onStop()
onDestroy()
Le système d'exploitation Android utilise une file d'attente prioritaire pour faciliter la gestion des activités exécutées sur le périphérique. En fonction de l'état dans lequel se trouve une activité Android particulière, une certaine priorité lui est 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, ce qui permet 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 au cours de sa 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é sommet de la pile d'activités. Cette activité est considérée comme l’activité prioritaire dans la pile d’activités Android et, en tant que telle, le système d’exploitation ne la supprimera que dans des situations extrêmes, par exemple si l’activité essaie d’utiliser plus de mémoire que ce qui est disponible sur le périphérique. cela pourrait empêcher l'interface utilisateur de répondre.
En pause - Lorsque l'appareil se met en veille ou qu'une activité est encore visible mais partiellement masquée par une nouvelle activité non pleine taille ou transparente, la fonction l'activité est considérée comme en pause. Les activités mises en veille sont toujours actives, c'est-à-dire qu'elles conservent toutes les informations sur l'état et les membres et restent attachées au gestionnaire de fenêtres. Cette activité est considérée comme la deuxième activité la plus prioritaire dans la pile d’activités Android et, en tant que telle, ne sera tuée par le système d’exploitation que si cette activité répond aux besoins en ressources nécessaires pour conserver l’activité active/en cours. stable et réactif.
Arrêté - Les activités 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 essaient 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, de ce fait, le système d'exploitation supprimera les activités dans cet état en premier pour satisfaire les besoins en ressources. 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");
}
}
Toute 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:
L'activité a six états
- Créé
- Démarré
- repris
- en pause
- Arrêté
- Détruit
Cycle de vie de l'activité a sept méthodes
onCreate()onStart()onResume()onPause()onStop()onRestart()onDestroy()
Situations
lors de l'ouverture de l'application
onCreate() --> onStart() --> onResume()lorsque le bouton de retour est enfoncé et quitte l'application
onPaused() -- > onStop() --> onDestory()lorsque le bouton d'accueil est enfoncé
onPaused() --> onStop()Après avoir appuyé sur le bouton d'accueil quand à nouveau ouvert l'application de la liste des tâches récentes ou cliqué sur l'icône
onRestart() --> onStart() --> onResume()Lorsque vous ouvrez une autre application à partir de la barre de notification ou des paramètres ouverts
onPaused() --> onStop()Le bouton Précédent enfoncé depuis une autre application ou les paramètres utilisés ensuite permettent de 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 Précédent de la boîte de dialogue
onResume()Tout téléphone sonne et utilisateur dans l'application
onPause() --> onResume()lorsque l'utilisateur appuie 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()
Sept méthodes permettent de gérer le cycle de vie d'une application Android:
Répondez à quoi servent toutes ces méthodes:
Prenons un scénario simple dans lequel savoir dans quel ordre ces méthodes sont appelées nous aidera à préciser 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 pour 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 passe au premier plan et deux méthodes sont maintenant appelées l'une après l'autre.
onPause() - - -> onStop()
- Maintenant, disons que je termine la conversation au téléphone, l’activité de la calculatrice passe de l’arrière-plan à l'avant-plan, de sorte que trois méthodes sont appelées successivement.
onRestart() - - -> onStart() - - -> onResume()
- Enfin, disons que j'ai terminé toutes les tâches dans l'application Calculatrice et que je veux quitter l'application. Deux méthodes sont appelées successivement.
onStop() - - -> onDestroy()
Une activité peut éventuellement exister dans quatre états:
- Etat de départ
- État en cours d'exécution
- état de pause
- état arrêté
L'état de départ implique:
Création d'un nouveau processus Linux, allocation d'une 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 en cours implique:
C'est l'activité (état) qui est actuellement à l'écran. Cet état à lui seul gère des choses telles que la saisie à l'écran et le toucher et le clic de boutons.
L'état de pause implique:
Lorsqu'une activité n'est pas au premier plan mais à l'arrière-plan, elle 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 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 et les performances de l'utilisateur soient toujours optimales, 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é de créer un diagramme incluant ceux-ci et leur relation avec le cycle de vie d'Android Fragment, à la page https://github.com/xxv/Android-lifecycle . J'ai révisé le grand diagramme de Steve pour n'inclure que la partie Activité et je l'ai formaté pour une impression d'une page au format lettre. Je l'ai posté sous forme de texte PDF sur https://github.com/code-read/Android-lifecycle/blob/master/AndroidActivityLifecycle1.pdf et ci-dessous se trouve sa image:
Depuis la page Android Developers,
onPause ():
Appelé lorsque le système est sur le point de commencer une activité précédente. Ceci est généralement utilisé pour valider des modifications non sauvegardées dans des données persistantes, arrêter des animations et d'autres éléments susceptibles de consommer de la CPU, etc. Les implémentations de cette méthode doivent être très rapides car l'activité suivante ne sera reprise qu'après le retour de cette méthode. Suivi par onResume () si l'activité revient au début, 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 été reprise et couvre celle-ci. Cela peut se produire soit parce qu’une nouvelle activité est en cours de démarrage, qu’une activité existante est présentée devant celle-ci ou que celle-ci est en cours de destruction. Suivi par onRestart () si cette activité revient pour interagir avec l'utilisateur, ou onDestroy () si cette activité est en train de disparaître.
Supposons maintenant qu'il existe trois activités et que vous alliez de A à B, puis onPause of A sera appelée de B à C, puis onPause de B et onStop of A seront appelées.
L’activité mise en pause reçoit un CV et l’arrêt est redémarré.
Lorsque vous appelez this.finish(), onPause-onStop-onDestroy sera appelé. La principale chose à retenir est: mise en pause Les activités sont arrêtées et une activité arrêtée est détruite à chaque fois que Android nécessite de la mémoire pour d'autres opérations.
J'espère que c'est assez clair.
Ajout de quelques informations supplémentaires en plus d'une réponse hautement coté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 la colonne " Killable " du tableau ci-dessus - pour les méthodes marquées comme pouvant être tuées, une fois que cette méthode a renvoyé le processus hébergeant l'activité, être tué par le système à tout moment sans qu'une autre ligne de son code soit exécutée.
Pour cette raison, vous devez utiliser la méthode onPause() pour écrire des données persistantes (telles que les modifications utilisateur) dans la mémoire. 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 de sauvegarder tout état d'instance dynamique de votre activité dans le Bundle donné, afin qu'il soit reçu ultérieurement dans 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), car ce dernier ne fait pas partie des rappels du cycle de vie. Par conséquent, il ne sera pas appelé dans toutes les situations décrites dans la documentation.
Je voudrais ajouter quelques méthodes supplémentaires. Celles-ci ne sont pas répertoriées en tant que méthodes du cycle de vie, mais elles seront appelées au cours du cycle de vie en fonction de certaines conditions. Selon vos besoins, vous devrez peut-être implémenter ces méthodes dans votre application pour un traitement correct de l'état.
onPostCreate(Bundle savedInstanceState)
Appelé lorsque le démarrage de l'activité est terminé (après que
onStart()etonRestoreInstanceState(Bundle)aient été appelés).
onPostResume()
Appelé lorsque la reprise de l'activité est terminée (après que
onResume()ait été appelé).
onSaveInstanceState(Bundle outState)
Appelé pour récupérer l'état d'une instance par activité à partir d'une activité avant d'être tué, afin que l'état puisse être restauré dans
onCreate(Bundle)ouonRestoreInstanceState(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 en cours de réinitialisation à partir d'un état précédemment enregistré, donné ici danssavedInstanceState.
Mon code d'application 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é même s'il ne s'agit pas d'une méthode de cycle de vie.
Quel est le cycle de vie d'une activité Android?
Dans Android sdk framework, Chaque activité Android _ (Fenêtre) ayant des méthodes de cycle de vie. Cela signifie que lorsque l'utilisateur entre dans une application, il peut voir l'activité qui a été créée dans la méthode de cycle de vie onCreate (). Les dispositions attachées dans la fenêtre dans la méthode onCreate () uniquement.
L'activité (fenêtre) présente les états de cycle de vie suivants:
Create - Activity is created.
Start - Current activity gets started.
Resume - Current activity has been in resumed state.
Restart - Current activity has been in restarted.
Pause - Current activity has been in Paused state.
Stop - Current activity has been in stopped state.
destroy - Current activity has been in destroyed state.
Pourquoi autant de méthodes de sondage similaires (onCreate (), onStart (), onResume ()) sont-elles appelées lors de l'initialisation et tant d'autres (onPause (), onStop (), onDestroy ()) sont-elles appelées à la fin?
First time user enter into an application:
Lors de l'ouverture de l'application, nous pouvons voir une fenêtre (activité). onCreate (créé) -> onStart (démarré) -> onResume (état de reprise) sera appelé.
Close the application from background:
lors de la fermeture de l'application en arrière-plan, l'activité doit être détruite pour libérer de la mémoire. Ainsi, les méthodes onPause -> onStop -> onDestroy seront appelées.
Quand ces méthodes sont-elles appelées et comment doivent-elles être utilisées correctement?
démarre l'application:
Lorsque l'utilisateur entre dans une activité ou une application pour la première fois:
onCreate()
onStart()
onResume()
Lorsque vous exécutez l'application depuis le studio Android:
onCreate()
onStart()
onResume()
Transition d'activité:
Lorsque vous quittez la première activité -> Deuxième activité:
first_activity : onPause()
second_activity : onCreate()
second_activity : onStart()
second_activity : onResume()
first_activity : onStop()
Lorsque vous quittez la deuxième activité -> Première activité:
second_activity : onPause()
first_activity : onRestart()
first_activity : onStart()
first_activity : onResume()
second_activity : onStop()
second_activity : onDestroy()
bouton Aperçu:
Lorsque l'utilisateur clique sur le bouton de vue d'ensemble (troisième bouton matériel - liste récente):
onPause()
onStop()
Après que l'utilisateur ait quitté le bouton Vue d'ensemble (ou), l'utilisateur est allé à d'autres applications de la liste récente pour revenir à l'application:
onRestart()
onStart()
onResume()
Bouton d'accueil:
Lorsque l'utilisateur clique sur le bouton d'accueil:
onPause()
onStop()
L'utilisateur recherche l'écran d'accueil et clique sur l'icône de l'application pour revenir à l'activité:
onRestart()
onStart()
onResume()
l'utilisateur reçoit un appel téléphonique:
Lorsque l'utilisateur dans une activité, un appel téléphonique est arrivé:
onPause()
onStop()
Si l'utilisateur n'assiste pas à l'appel, il se déconnecte automatiquement et revient à l'activité (appel manqué):
onRestart()
onStart()
onResume()
Si l'utilisateur ne participe pas à l'appel:
N/A - Aucun cycle de vie ne sera appelé.
Bouton d'arrêt:
Lorsque l'utilisateur éteint le bouton:
onPause()
onStop()
Lorsque déverrouille l'appareil:
onRestart()
onStart()
onResume()
Pop Up Dialog:
Lorsque la boîte de dialogue contextuelle est apparue - aucun cycle de vie ne sera appelé
Redémarrer l'appareil ou éteindre:
Lorsque l'utilisateur redémarre ou éteint le périphérique:
onPause()
onStop()
Lorsque l'utilisateur clique sur l'icône de l'application à partir de l'écran d'accueil:
onCreate()
onStart()
onResume()