Cycle de vie de l'activité lorsqu'Android bascule entre les écrans horizontaux et verticaux

Cet article analyse le cycle de vie complet de l'activité dans la programmation Android avec des exemples. Partagez-le avec tout le monde pour référence, comme suit :

Les activités dans Android ont leurs propres cycles de vie. L'apprentissage de ces connaissances peut nous aider à mieux comprendre certaines des erreurs que nous rencontrerons lors de l'écriture de programmes à l'avenir. Cet article est très long, j'espère qu'il ne prendra pas le temps de tout le monde~

Aujourd'hui, je n'aborderai pas trop la pile d'activités, mais principalement le cycle de vie de l'activité elle-même

Distinguer plusieurs concepts

1 Activité L'explication officielle est « Une activité est un composant d'application qui fournit un écran avec lequel les utilisateurs peuvent interagir afin de faire quelque chose, comme composer un numéro de téléphone, prendre une photo, envoyer un e-mail ou afficher une carte. Chaque activité reçoit une fenêtre dans laquelle dessiner son interface utilisateur. "C'est-à-dire que chaque fenêtre que l'utilisateur utilise pour interagir, une opération qu'il effectue actuellement.

2 back-stack L'utilisateur démarrera une activité A via le lanceur d'application en touchant le programme. L'activité démarrée A sera poussée en haut de la pile si l'activité en cours A démarre une nouvelle activité B. , alors lorsque A appelle la fonction onStop, le système conservera ces informations d'activité. Lorsque l'utilisateur appuie sur la touche retour, la pile arrière effectuera une opération pop et appellera onResume() de A. Les détails spécifiques du popping et du popping de la pile. sera présenté en détail ultérieurement.

3 Tâches Lorsque l'utilisateur est dans une activité : L'activité A est nommée "Application TaskOne", appuyez sur la touche HOME et l'utilisateur revient au lanceur. A ce moment, si l'utilisateur touche à nouveau une nouvelle application, une nouvelle application sera créée. Une tâche et une pile arrière représentent une tâche. Les activités de différents programmes peuvent être poussées dans la même pile, ce qui signifie qu'elles peuvent former une tâche. Par exemple, votre programme démarre une activité de messagerie texte qui l'accompagne. le système, donnant à l'utilisateur l'impression que l'envoi de messages texte est une fonction de votre programme

Remarque : les comportements ci-dessus sont les paramètres par défaut du système. Il existe deux façons de modifier le comportement de l'activité. L'une consiste à ajouter A pour démarrer B. Dans les paramètres du manifeste de B, modifiez le comportement. L'autre consiste à spécifier les paramètres d'activité à démarrer dans l'intention initiée par l'activité. La priorité de l'intention est supérieure à celle du fichier manifest.xml. , et certains modes n'existent pas en même temps.

Le cycle de vie d'Android inclut onCreate onStart onRestart onResume onPause onStop onDestroy L'activité appellera les méthodes ci-dessus pendant le cycle de déclaration pour effectuer des opérations. correspondant à différents états. L'heure d'appel de chaque méthode est présentée ci-dessous

onCreate() L'activité ne peut pas être terminée dans cet état
Appelée lors de la première création de l'activité. C'est ici que vous devez tout faire. 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().
//Vous devez l'appeler lors de la première création de l'activité. Effectuez toutes les créations statiques dans cette méthode, créez des vues, liez les données aux listes (via la méthode setContnetView), etc. Cette méthode vous fournit également un bundle qui contient le l'état le plus récent de l'activité dans la méthode onStart.

Toujours suivi de onStart() est toujours appelé après l'arrêt de votre activité, avant qu'elle ne soit redémarrée

//Appelé lorsque votre activité est arrêtée et appelée avant de redémarrer.

onResume() fois où l'activité ne peut pas être terminée.
Appelé lorsque l'activité commencera à interagir avec l'utilisateur. À ce stade, votre activité se trouve en haut de la pile d'activités, avec les entrées de l'utilisateur.

Toujours suivi de onPause().

//Appelé lorsque l'activité sera démarrée pour interagir avec l'utilisateur. À ce moment, votre activité se trouve en haut de la pile d'activités et est utilisée pour la saisie de l'utilisateur. Elle sera toujours appelée après onPause, lorsque le système est sur le point de commencer à reprendre une activité précédente. Ceci est généralement utilisé pour valider les modifications non enregistrées dans la persistance. données, arrêter les animations et autres choses qui peuvent consommer du CPU, etc. Les implémentations de cette méthode doivent être très rapides car la prochaine activité ne reprendra pas tant que cette méthode ne reviendra pas.
Suivi soit de onResume() si l'activité revient au premier plan, ou onStop() s'il devient invisible pour l'utilisateur.

//Quand le système est sur le point de redémarrer Il est appelé lors de l'activité précédente (je ne comprends pas, ma compréhension est : elle est appelée lorsque l'activité en cours souhaite démarrer une nouvelle activité), une application typique est utilisée pour soumettre les données non enregistrées aux données actuelles (ce qui signifie simplement enregistrer les mises à jour des données), arrêter les animations et autres opérations susceptibles de consommer du processeur. La mise en œuvre de cette méthode doit être rapide car l’activité suivante ne sera redémarrée qu’au retour de cette méthode.

Lorsque l'activité passe de l'arrière (l'arrière-plan de la traduction n'est pas adapté) à l'avant (l'état d'interaction avec l'utilisateur), la méthode onResume sera appelée après la méthode onPause

Lorsque l'activité devient invisible, la méthode onStop sera appelée après onPause

onStop() L'activité peut être terminée dans plusieurs états
Appelée lorsque l'activité n'est plus visible par l'utilisateur, car une autre activité a repris et couvre celle-ci. Cela peut arriver soit parce qu'une nouvelle activité est démarrée, soit parce qu'une activité existante est amenée devant celle-ci, soit celle-ci est détruite.
Suivi soit par onRestart( ) si cette activité revient pour interagir avec l'utilisateur, ou onDestroy() si cette activité disparaît.

//Appelé lorsque l'activité n'est plus visible par l'utilisateur car une autre activité redémarre et écrase l'activité en cours (sur la pile). Lorsqu'une nouvelle activité est démarrée, ou qu'une activité existante revient au premier plan, ou que l'activité en cours est détruite. Si l'activité veut revenir au premier plan et interagir avec l'utilisateur, la méthode onReatart sera appelée après cette méthode. Si l'activité en cours va mourir, la méthode onDestroy sera appelée après cette méthode

onDestroy. () fois. L'activité peut être terminée dans cet état.
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 a appelé finish() dessus), soit parce que le système l'est. détruire temporairement cette instance de l'activité pour économiser de l'espace. Vous pouvez distinguer ces deux scénarios avec la méthode isFinishing(). Au lieu de cela, le système détruit l'instance d'activité pour libérer de l'espace. méthode onPause pour déterminer si l'activité est suspendue ou terminée. La démo suivante le démontrera

L'image ci-dessous est une démonstration du cycle de vie du site officiel

D'accord, jetons un coup d'œil à un exemple de démonstration que j'ai écrit,

MainFest.xml

Fichier de mise en page main.xml

<?xml version="1.0" encoding="utf-8"?> 
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
   package="uni.activity"
   android:versionCode="1"
   android:versionName="1.0"> 
  <uses-sdk android:minSdkVersion="7" /> 
  <application android:icon="@drawable/icon" android:label="@string/app_name"> 
    <activity android:name=".ActivityDemoActivity"
         android:label="@string/app_name"> 
      <intent-filter> 
        <action android:name="android.intent.action.MAIN" /> 
        <category android:name="android.intent.category.LAUNCHER" /> 
      </intent-filter> 
    </activity> 
    <activity android:name=".Activity01"
         android:label="@string/app_name"> 
    </activity> 
  </application> 
</manifest>

activity01 .xml

<?xml version="1.0" encoding="utf-8"?> 
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
  android:orientation="vertical"
  android:layout_width="fill_parent"
  android:layout_height="fill_parent"
  > 
<TextView 
  android:layout_width="fill_parent" 
  android:layout_height="wrap_content" 
  android:text="@string/hello"
  /> 
 <Button 
  android:id="@+id/Button_A"
  android:text="GO to activity 2"
  android:layout_width="fill_parent"
  android:layout_height="wrap_content"
  /> 
</LinearLayout>

String.xml

<?xml version="1.0" encoding="utf-8"?> 
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
  android:orientation="vertical"
  android:layout_width="fill_parent"
  android:layout_height="fill_parent"
  > 
<TextView 
  android:layout_width="fill_parent" 
  android:layout_height="wrap_content" 
  android:text="@string/hello"
  /> 
 <Button 
  android:id="@+id/Button_A"
  android:text="GO to activity 2"
  android:layout_width="fill_parent"
  android:layout_height="wrap_content"
  /> 
</LinearLayout>

ActivityDemoActivity.java

<?xml version="1.0" encoding="utf-8"?> 
<resources> 
  <string name="hello">Hello World, ActivityDemoActivity!</string> 
  <string name="app_name">ActivityDemo</string> 
  <string name="activity01">this is activity 01</string> 
</resources>

Activity01.java

/* 
 * @author octobershiner 
 * 2011 07 29 
 * SE.HIT 
 * 演示完整的activity的声明周期，以及isFinish方法的调用 
 * 此activity为程序入口activity 
 * */ 
package uni.activity; 
import android.app.Activity; 
import android.content.Intent; 
import android.os.Bundle; 
import android.util.Log; 
import android.view.View; 
import android.view.View.OnClickListener; 
import android.widget.Button; 
public class ActivityDemoActivity extends Activity { 
  /** Called when the activity is first created. */
  private static final String TAG = "demo"; 
  private Button button_A; 
  @Override
  public void onCreate(Bundle savedInstanceState) { 
    super.onCreate(savedInstanceState); 
    setContentView(R.layout.main); 
    button_A = (Button)this.findViewById(R.id.Button_A); 
    button_A.setOnClickListener(new myButtonListener()); 
  } 
  private class myButtonListener implements OnClickListener{ 
    @Override
    public void onClick(View v) { 
      // TODO Auto-generated method stub 
      Intent intent = new Intent(); 
      intent.setClass(ActivityDemoActivity.this, Activity01.class); 
      ActivityDemoActivity.this.startActivity(intent); 
      //感兴趣的朋友可以取消下面的代码注释，来测试finish方法的使用，会发现第一个activity会被强制终止 
      //ActivityDemoActivity.this.finish(); 
    } 
  }; 
  protected void onStart(){ 
    super.onStart(); 
    Log.i(TAG, "The activityDemo state---->onStart"); 
  } 
  protected void onRestart(){ 
    super.onRestart(); 
    Log.i(TAG, "The activityDemo state---->onReatart"); 
  } 
  protected void onResume(){ 
    super.onResume(); 
    Log.i(TAG, "The activityDemo state---->onResume"); 
  } 
  protected void onPause(){ 
    super.onPause(); 
    //调用isFinishing方法，判断activity是否要销毁 
    Log.i(TAG, "The activityDemo state---->onPause"); 
    if(isFinishing()){ 
      Log.w(TAG, "The activityDemo will be destroyed!"); 
    }else{ 
      Log.w(TAG, "The activityDemo is just pausing!"); 
    } 
  } 
  protected void onStop(){ 
    super.onStop(); 
    Log.i(TAG, "The activityDemo state---->onStop"); 
  } 
  protected void onDestroy(){ 
    super.onDestroy(); 
    Log.i(TAG, "The activityDemo state---->onDestroy"); 
  } 
}

Ce qui suit est le résultat de la démonstration,

/* 
 * @author octobershiner 
 * 2011 07 29 
 * SE.HIT 
 * 演示完整的activity的声明周期，以及isFinish方法的调用 
 * 此activity可由ActivityDemoActivity启动 
 * */
package uni.activity; 
import android.app.Activity; 
import android.os.Bundle; 
import android.util.Log; 
public class Activity01 extends Activity{ 
  private static final String TAG = "demo"; 
  @Override
  protected void onCreate(Bundle savedInstanceState) { 
    // TODO Auto-generated method stub 
    super.onCreate(savedInstanceState); 
    setContentView(R.layout.activity01); 
    Log.d(TAG, "The activity01 state---->onStart"); 
  } 
   protected void onStart(){ 
      super.onStart(); 
      Log.d(TAG, "The activity01 state---->onStart"); 
    } 
    protected void onRestart(){ 
      super.onRestart(); 
      Log.d(TAG, "The activity01 state---->onReatart"); 
    } 
    protected void onResume(){ 
      super.onResume(); 
      Log.d(TAG, "The activity01 state---->onResume"); 
    } 
    protected void onPause(){ 
      super.onPause(); 
      Log.d(TAG, "The activity01 state---->onPause"); 
      //调用isFinishing方法，判断activity是否要销毁 
      if(isFinishing()){ 
        Log.w(TAG, "The activity01 will be destroyed!"); 
      }else{ 
        Log.w(TAG, "The activity01 is just pausing!"); 
      } 
    } 
    protected void onStop(){ 
      super.onStop(); 
      Log.d(TAG, "The activity01 state---->onStop"); 
    } 
    protected void onDestroy(){ 
      super.onDestroy(); 
      Log.d(TAG, "The activity01 state---->onDestroy"); 
    } 
}

Le processus d'opération est : Démarrer ActivityDemoActivity

Cliquez ensuite sur le bouton pour entrer dans Activity01

(On peut voir que l'activité est d'abord mise en pause et ne sera pas libérée. Il s'agit en fait d'un processus de poussée d'une nouvelle activité, puis lorsqu'une nouvelle activité démarre, elle devrait être onCreate puis onStart. J'ai écrit la mauvaise déclaration d'impression. Les amis attentifs auraient dû voir que lorsque l'ancienne activité n'est pas visible, sa méthode onStop est appelée)

Appuyez ensuite sur la touche retour pour revenir à ActivityDemoActivity

(Après le retour, Activity01 en haut de la pile effectuera une opération de pop-pile et l'affichage sera détruit)

Appuyez à nouveau sur la touche retour pour revenir au bureau

En fait, l'écriture de Dongxie est un peu longue, mais elle montre essentiellement le cycle de vie complet de l'activité.

J'espère que cet article sera utile à tout le monde dans la programmation Android.

Pour plus d'articles liés au cycle de vie de l'activité lorsqu'Android bascule entre les écrans horizontaux et verticaux, veuillez faire attention au site Web PHP chinois !