Aktivitätslebenszyklus und -status verwenden

1. Willkommen

Dieses praktische Codelab ist Teil von „Modul 1: Erste Schritte“ im Kurs „Grundlagen für Android-Entwickler (Version 2)“. Den größtmöglichen Nutzen aus diesem Kurs ziehen Sie, wenn Sie die Codelabs der Reihe nach durcharbeiten:

  • Eine vollständige Liste der Codelabs im Kurs finden Sie unter Codelabs for Android Developer Fundamentals (V2).
  • Details zum Kurs, einschließlich Links zu allen Konzeptkapiteln, Apps und Folien, findest du unter Android Developer Fundamentals (Version 2).

Einleitung

In dieser praktischen Übung erfahren Sie mehr über den Aktivitätslebenszyklus. Der Lebenszyklus ist die Gruppe von Status, die eine Aktivität während ihrer gesamten Lebensdauer haben kann, von ihrer Erstellung bis zu ihrer Zerstörung und der Freigabe der Ressourcen durch das System. Wenn ein Nutzer zwischen Aktivitäten in Ihrer App hin- und herbewegt, wechseln die Aktivitäten in ihrem Lebenszyklus zwischen verschiedenen Status.

Doppelte Probleme

Jede Phase im Lebenszyklus einer Aktivität verfügt über eine entsprechende Callback-Methode: onCreate(), onStart(), onPause() usw. Wenn sich der Status einer Aktivität ändert, wird die zugehörige Callback-Methode aufgerufen. Sie kennen bereits eine dieser Methoden: onCreate(). Wenn Sie eine der Lebenszyklus-Callback-Methoden in Ihren Activity-Klassen überschreiben, können Sie das Standardverhalten der Aktivität als Reaktion auf Nutzer- oder Systemaktionen ändern.

Der Aktivitätsstatus kann sich auch als Reaktion auf Änderungen an der Gerätekonfiguration ändern, z. B. wenn der Nutzer das Gerät vom Hochformat ins Querformat dreht. Wenn diese Konfigurationsänderungen erfolgen, wird die Aktivität gelöscht und im Standardzustand neu erstellt. Dabei kann es sein, dass der Nutzer Informationen verliert, die er in die Aktivität eingegeben hat. Um deine Nutzer nicht zu verwirren, ist es wichtig, dass du deine App entwickelst, um einen unerwarteten Datenverlust zu vermeiden. Später in dieser praktischen Übung experimentieren Sie mit Konfigurationsänderungen und erfahren, wie Sie den Status einer Aktivität als Reaktion auf Änderungen der Gerätekonfiguration und andere Ereignisse im Aktivitätslebenszyklus beibehalten.

In dieser praktischen Übung fügen Sie der TwoActivities-App Logging-Anweisungen hinzu und beobachten Änderungen im Aktivitätslebenszyklus, während Sie die App verwenden. Anschließend beginnen Sie mit diesen Änderungen und untersuchen, wie Sie Nutzereingaben unter diesen Bedingungen handhaben.

Voraussetzungen

Sie sollten Folgendes können:

  • Erstellen Sie ein App-Projekt in Android Studio und führen Sie es aus.
  • Fügen Sie Ihrer Anwendung Log-Anweisungen hinzu und sehen Sie sich diese Logs im Logcat-Bereich an.
  • Verstehen und arbeiten Sie mit einer Aktivität und einem Intent und achten Sie darauf, mit ihnen zu interagieren.

Lerninhalte

  • Funktionsweise des Aktivitätslebenszyklus.
  • Wenn eine Aktivität startet, pausiert, stoppt und gelöscht wird.
  • Informationen zu den Lebenszyklus-Callback-Methoden, die mit Aktivitätsänderungen verknüpft sind.
  • Die Auswirkungen von Aktionen (z. B. Konfigurationsänderungen), die zu Ereignissen im Aktivitätslebenszyklus führen können.
  • So wird der Aktivitätsstatus über Lebenszyklusereignisse hinweg beibehalten.

Aufgaben

  • Fügen Sie der App TwoActivities aus der vorherigen praktischen Anwendung Code hinzu, um die verschiedenen Callbacks für den Aktivitätslebenszyklus zu implementieren, in denen Logging-Anweisungen enthalten sind.
  • Beobachte, wie sich der Status ändert, während deine App ausgeführt wird und wenn du mit den einzelnen Aktivitäten in deiner App interagierst.
  • Ändern Sie Ihre App so, dass der Instanzstatus einer Aktivität beibehalten wird, die als Reaktion auf Nutzerverhalten oder Konfigurationsänderungen auf dem Gerät unerwartet neu erstellt wird.

2. App-Übersicht

In dieser praktischen Übung fügen Sie die App TwoActivities hinzu. Aussehen und Verhalten der App entsprechen ungefähr dem vorherigen Codelab. Es enthält zwei Activity-Implementierungen und bietet dem Nutzer die Möglichkeit, Daten zwischen diesen zu senden. Die Änderungen, die Sie in dieser praktischen Anwendung an der App vornehmen, haben keinen Einfluss auf das sichtbare Nutzerverhalten.

3. 3. Aufgabe 1: Lebenszyklus-Callbacks zu TwoActivities hinzufügen

In dieser Aufgabe implementieren Sie alle Callback-Methoden für den Aktivitätslebenszyklus, mit denen Nachrichten an Logcat ausgegeben werden, wenn diese Methoden aufgerufen werden. Anhand dieser Logeinträge können Sie sehen, wann sich der Aktivitätslebenszyklus ändert und wie sich diese Änderungen beim Lebenszyklus auf Ihre App auswirken.

1.1 (Optional) TwoActivities-Projekt kopieren

Für die Aufgaben in dieser Praxis ändern Sie das vorhandene TwoActivities-Projekt, das Sie im letzten praktischen Projekt erstellt haben. Wenn Sie das vorherige TwoActivities-Projekt intakt lassen möchten, erstellen Sie eine Kopie des Projekts gemäß der Anleitung in Anhang: Dienstprogramme.

1.2 Callbacks in MainActivity implementieren

  1. Öffnen Sie in Android Studio das TwoActivities-Projekt und wählen Sie im Bereich „Projekt“ > „Android“ „MainActivity“ aus.
  2. Fügen Sie in der Methode onCreate() die folgenden Loganweisungen hinzu:
Log.d(LOG_TAG, "-------");
Log.d(LOG_TAG, "onCreate");
  1. Fügen Sie eine Überschreibung für den onStart()-Callback mit einer Anweisung zum Protokoll für dieses Ereignis hinzu:
@Override
public void onStart(){
    super.onStart();
    Log.d(LOG_TAG, "onStart");
}

Für eine Tastenkombination wählen Sie in Android Studio Code > Überschreibungsmethoden aus. Es wird ein Dialogfeld mit allen Methoden angezeigt, die Sie in Ihrer Klasse überschreiben können. Wenn Sie eine oder mehrere Callback-Methoden aus der Liste auswählen, wird eine vollständige Vorlage für diese Methoden eingefügt, einschließlich des erforderlichen Aufrufs an die übergeordnete Klasse.

  1. onStart()-Methode als Vorlage verwenden, um die Lebenszyklus-Callbacks onPause(), onReboot(), onResume(), onStop() und onDestroy() zu implementieren

Alle Callback-Methoden haben dieselben Signaturen, mit Ausnahme des Namens. Wenn Sie onStart() kopieren und einfügen, um diese anderen Callback-Methoden zu erstellen, vergessen Sie nicht, den Inhalt zu aktualisieren, damit die richtige Methode in der Basisklasse aufgerufen und die richtige Methode protokolliert wird.

  1. Führen Sie die Anwendung aus.
  2. Klicken Sie unten in Android Studio auf die Registerkarte „Logcat“, um den Logcat-Bereich anzuzeigen. Es sollten drei Protokollmeldungen mit den drei Lebenszyklusstatus angezeigt werden, die die Aktivität beim Start durchlaufen hat:
D/MainActivity: -------
D/MainActivity: onCreate
D/MainActivity: onStart
D/MainActivity: onResume

1.3 Lebenszyklus-Callbacks in SecondActivity implementieren

Nachdem Sie nun die Lebenszyklus-Callback-Methoden für MainActivity implementiert haben, gehen Sie genauso vor für SecondActivity.

  1. Öffnen Sie SecondActivity.
  2. Fügen Sie am Anfang der Klasse eine Konstante für die Variable LOG_TAG hinzu:
private static final String LOG_TAG = SecondActivity.class.getSimpleName();
  1. Fügen Sie der zweiten Aktivität die Lebenszyklus-Callbacks und Loganweisungen hinzu. Sie können die Callback-Methoden aus MainActivity kopieren und einfügen.
  2. Fügen Sie der Methode "returnReply()" direkt vor der Methode "Finish()" eine Loganweisung hinzu:
Log.d(LOG_TAG, "End SecondActivity");

1.4 Protokoll während der Ausführung der Anwendung beobachten**

  1. Führen Sie die Anwendung aus.
  2. Klicken Sie unten in Android Studio auf die Registerkarte „Logcat“, um den Logcat-Bereich anzuzeigen.
  3. Geben Sie „Aktivität“ in das Suchfeld ein. Der Android-Logcat kann sehr lang und unübersichtlich sein. Da die Variable LOG_TAG in jeder Klasse entweder die Wörter „MainActivity“ oder „SecondActivity“ enthält, können Sie mit diesem Suchbegriff das Protokoll nur nach Dingen filtern, die Sie interessieren.

Doppelte Probleme

Experimentieren Sie mit Ihrer App und beachten Sie dabei die Lebenszyklusereignisse, die als Reaktion auf verschiedene Aktionen auftreten. Versuchen Sie insbesondere Folgendes:

  • Verwende die App wie gewohnt (Nachricht senden, mit einer anderen Nachricht antworten).
  • Mit der Zurück-Schaltfläche kannst du von der zweiten Aktivität zur Hauptaktivität zurückkehren.
  • Mit dem Aufwärtspfeil in der App-Leiste gelangen Sie von der zweiten Aktivität zur Hauptaktivität zurück.
  • Drehe das Gerät in der App zu unterschiedlichen Zeiten in der Haupt- und der zweiten Aktivität und beobachte, was im Protokoll * und auf dem Bildschirm passiert.
  • Drücke die Übersichtsschaltfläche (die quadratische Schaltfläche rechts neben dem Startbildschirm) und schließe die App, indem du auf das „X“ tippst.
  • Kehren Sie zum Startbildschirm zurück und starten Sie die App neu.

TIPP: Wenn Sie Ihre App in einem Emulator ausführen, können Sie die Rotation mit Strg+F11 oder Strg+Funktion+F11 simulieren.

Lösungscode für Aufgabe 1

Die folgenden Code-Snippets zeigen den Lösungscode für die erste Aufgabe.

MainActivity

Die folgenden Code-Snippets zeigen den in MainActivity hinzugefügten Code, aber nicht die gesamte Klasse.

Die onCreate()-Methode:

@Override
protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        // Log the start of the onCreate() method.
        Log.d(LOG_TAG, "-------");
        Log.d(LOG_TAG, "onCreate");

        // Initialize all the view variables.
        mMessageEditText = findViewById(R.id.editText_main);
        mReplyHeadTextView = findViewById(R.id.text_header_reply);
        mReplyTextView = findViewById(R.id.text_message_reply);
}

Die anderen Lebenszyklusmethoden:

@Override
protected void onStart() {
        super.onStart();
        Log.d(LOG_TAG, "onStart");
}

@Override
protected void onPause() {
        super.onPause();
        Log.d(LOG_TAG, "onPause");
}

@Override
protected void onRestart() {
        super.onRestart();
        Log.d(LOG_TAG, "onRestart");
}

@Override
protected void onResume() {
        super.onResume();
        Log.d(LOG_TAG, "onResume");
}

@Override
protected void onStop() {
        super.onStop();
        Log.d(LOG_TAG, "onStop");
}

@Override
protected void onDestroy() {
        super.onDestroy();
        Log.d(LOG_TAG, "onDestroy");
}

SecondActivity

Die folgenden Code-Snippets zeigen den in SecondActivity hinzugefügten Code, aber nicht die gesamte Klasse.

Oben in der SecondActivity-Klasse:

private static final String LOG_TAG = SecondActivity.class.getSimpleName();

Die ReturnReply()-Methode:

public void returnReply(View view) {
        String reply = mReply.getText().toString();
        Intent replyIntent = new Intent();
        replyIntent.putExtra(EXTRA_REPLY, reply);
        setResult(RESULT_OK, replyIntent);
        Log.d(LOG_TAG, "End SecondActivity");
        finish();
}

Die anderen Lebenszyklusmethoden:

Wie oben für MainActivity.

4. 4. Aufgabe 2: Status der Aktivitätsinstanz speichern und wiederherstellen

Abhängig von den Systemressourcen und dem Nutzerverhalten kann jede Aktivität in Ihrer App viel häufiger gelöscht und rekonstruiert werden, als Sie vielleicht denken.

Dieses Verhalten ist Ihnen vielleicht im letzten Abschnitt aufgefallen, als Sie das Gerät oder den Emulator gedreht haben. Das Drehen des Geräts ist ein Beispiel für eine Änderung der Gerätekonfiguration. Obwohl die Rotation am häufigsten ist, führen alle Konfigurationsänderungen dazu, dass die aktuelle Aktivität gelöscht und neu erstellt wird, als wäre sie neu. Wenn Sie dieses Verhalten in Ihrem Code nicht berücksichtigen, wird Ihr Aktivitätslayout bei einer Konfigurationsänderung auf die Standarddarstellung und die Anfangswerte zurückgesetzt. Dadurch verlieren Ihre Nutzer möglicherweise ihren Platz, ihre Daten oder den Status ihres Fortschritts in der App.

Der Status jeder Aktivität wird als eine Reihe von Schlüssel/Wert-Paaren in einem Bundle-Objekt gespeichert, das als Activity-Instanzstatus bezeichnet wird. Das System speichert Informationen zum Standardstatus im Instanzstatus-Bundle, kurz bevor die Activity beendet wird, und übergibt dieses Bundle zur Wiederherstellung an die neue Activity-Instanz.

Um zu verhindern, dass Daten in einer Activity verloren gehen, wenn diese unerwartet gelöscht und neu erstellt wird, müssen Sie die onSaveInstanceState() -Methode implementieren. Das System ruft diese Methode für Ihre Activity (zwischen onPause() und onStop()) auf, wenn die Möglichkeit besteht, dass die Activity gelöscht und neu erstellt wird.

Die Daten, die Sie im Instanzstatus speichern, gelten nur für diese Instanz dieser speziellen Activity während der aktuellen App-Sitzung. Wenn Sie eine neue App-Sitzung beenden und neu starten, geht der Status der Aktivitätsinstanz verloren und die Aktivität wird auf die Standarddarstellung zurückgesetzt. Wenn Sie Nutzerdaten zwischen App-Sitzungen speichern möchten, verwenden Sie gemeinsame Einstellungen oder eine Datenbank. Beides erfahren Sie in einer späteren praktischen Übung.

2.1 Status der Activity-Instanz mit onSaveInstanceState() speichern

Vielleicht haben Sie bemerkt, dass sich das Drehen des Geräts überhaupt nicht auf den Status der zweiten Aktivität auswirkt. Das liegt daran, dass das zweite Activity-Layout und -Status aus dem Layout und dem Intent generiert werden, mit dem es aktiviert wurde. Auch wenn die Activity neu erstellt wird, ist der Intent weiterhin vorhanden und die Daten in diesem Intent werden weiterhin verwendet, wenn die onCreate()-Methode in der zweiten Activity aufgerufen wird.

Außerdem bemerken Sie möglicherweise, dass jeder Text, den Sie in EditText-Elemente einer Nachricht oder Antwort eingegeben haben, in jeder Aktivität beibehalten wird, selbst wenn das Gerät gedreht wird. Das liegt daran, dass die Statusinformationen einiger View-Elemente in Ihrem Layout bei Konfigurationsänderungen automatisch gespeichert werden. Der aktuelle Wert eines „EditText“-Objekts ist einer dieser Fälle.

Der einzige Activity-Status, der für Sie von Interesse ist, sind also die TextView-Elemente für den Antwort-Header und den Antwort-Text in der Hauptaktivität. Beide TextView-Elemente sind standardmäßig nicht sichtbar. Sie werden erst angezeigt, wenn Sie eine Nachricht aus der zweiten Activity-Klasse an die Hauptaktivität zurücksenden.

In dieser Aufgabe fügen Sie mithilfe von onSaveInstanceState() Code hinzu, um den Instanzstatus dieser beiden TextView-Elemente beizubehalten.

  1. Öffnen Sie MainActivity.
  2. Fügen Sie die grundlegende Implementierung von onSaveInstanceState() zur Aktivität hinzu oder verwenden Sie Code > Override Methods, um eine grundlegende Überschreibung einzufügen.
@Override
public void onSaveInstanceState(Bundle outState) {
          super.onSaveInstanceState(outState);
}
  1. Überprüfen Sie, ob der Header derzeit sichtbar ist. Wenn ja, fügen Sie diesen Sichtbarkeitsstatus mit der Methode putBoolesch() und dem Schlüssel "reply_visible" in das Status-Bundle ein.
 if (mReplyHeadTextView.getVisibility() == View.VISIBLE) {
        outState.putBoolean("reply_visible", true);
    }

Denken Sie daran, dass die Überschrift und der Text der Antwort als unsichtbar markiert sind, bis eine Antwort aus der zweiten Aktivität vorliegt. Wenn der Header sichtbar ist, müssen Antwortdaten gespeichert werden. Wir sind nur an diesem Sichtbarkeitsstatus interessiert. Der eigentliche Text der Überschrift muss nicht gespeichert werden, da er sich nie ändert.

  1. Fügen Sie innerhalb desselben Häkchens den Antworttext der Gruppierung hinzu.
outState.putString("reply_text",mReplyTextView.getText().toString());

Wenn der Header sichtbar ist, können Sie davon ausgehen, dass auch die Antwortnachricht selbst sichtbar ist. Sie müssen den aktuellen Sichtbarkeitsstatus der Antwortnachricht nicht testen oder speichern. Nur der eigentliche Text der Nachricht wird mit dem Schlüssel „reply_text“ in das Status-Bundle aufgenommen.

Sie speichern nur den Status der View-Elemente, die sich nach dem Erstellen der Aktivität ändern könnten. Die anderen View-Elemente in Ihrer App (EditText, Button) können jederzeit über das Standardlayout neu erstellt werden.

Beachten Sie, dass das System den Status einiger View-Elemente speichert, z. B. den Inhalt von EditText.

2.2 Status der Activity-Instanz in onCreate() wiederherstellen

Nachdem Sie den Status der Activity-Instanz gespeichert haben, müssen Sie ihn auch wiederherstellen, wenn die Activity neu erstellt wird. Sie können dies entweder in onCreate() tun oder indem Sie den onRestoreInstanceState()-Callback implementieren, der nach der Erstellung der Aktivität nach onStart() aufgerufen wird.

Meistens ist der bessere Ort zum Wiederherstellen des Aktivitätsstatus in onCreate(), um sicherzustellen, dass die Benutzeroberfläche, einschließlich des Status, so schnell wie möglich verfügbar ist. Manchmal ist es praktisch, dies in onRestoreInstanceState() durchzuführen, nachdem die gesamte Initialisierung abgeschlossen ist, oder Unterklassen die Entscheidung zu überlassen, ob Ihre Standardimplementierung verwendet werden soll.

  1. Fügen Sie in der onCreate()-Methode nach der Initialisierung der View-Variablen mit findViewById() einen Test hinzu, um sicherzustellen, dass savedInstanceState nicht null ist.
// Initialize all the view variables.
mMessageEditText = findViewById(R.id.editText_main);
mReplyHeadTextView = findViewById(R.id.text_header_reply);
mReplyTextView = findViewById(R.id.text_message_reply);

// Restore the state.
if (savedInstanceState != null) {
}

Wenn Ihre Aktivität erstellt wird, übergibt das System das Status-Bundle als einziges Argument an onCreate(). Beim ersten Aufruf von onCreate() und beim Start Ihrer App ist das Bundle null. Beim ersten Start Ihrer App ist kein Status vorhanden. Bei nachfolgenden Aufrufen von onCreate() wird ein Bundle mit den Daten gefüllt, die Sie in onSaveInstanceState() gespeichert haben.

  1. In dieser Prüfung können Sie mit dem Schlüssel „reply_visible“ die aktuelle Sichtbarkeit (true oder false) aus dem Bundle abrufen.
if (savedInstanceState != null) {
    boolean isVisible = 
                     savedInstanceState.getBoolean("reply_visible");
}
  1. Fügen Sie unter der vorherigen Zeile einen Test für die Variable „isvisible“ hinzu.
if (isVisible) {
}

Wenn das Status-Bundle einen „response_visible“-Schlüssel enthält (und isvisible „true“ ist), müssen Sie den Status wiederherstellen.

  1. Machen Sie den Header innerhalb des isvisible-Tests sichtbar.
mReplyHeadTextView.setVisibility(View.VISIBLE);
  1. Rufen Sie die Text-Antwort-Nachricht aus dem Bundle mit dem Schlüssel "reply_text" ab und legen Sie die Antwort-TextView so fest, dass diese Zeichenfolge angezeigt wird.
mReplyTextView.setText(savedInstanceState.getString("reply_text"));
  1. Machen Sie auch die TextView für die Antwort sichtbar:
mReplyTextView.setVisibility(View.VISIBLE);
  1. Führen Sie die App aus. Versuchen Sie, das Gerät oder den Emulator zu drehen, um sicherzustellen, dass die Antwortnachricht (falls vorhanden) auf dem Bildschirm verbleibt, nachdem die Aktivität neu erstellt wurde.

Lösungscode für Aufgabe 2

Die folgenden Code-Snippets zeigen den Lösungscode für diese Aufgabe.

MainActivity

Die folgenden Code-Snippets zeigen den in MainActivity hinzugefügten Code, aber nicht die gesamte Klasse.

Die onSaveInstanceState()-Methode:

@Override
public void onSaveInstanceState(Bundle outState) {
   super.onSaveInstanceState(outState);
   // If the heading is visible, message needs to be saved.
   // Otherwise we're still using default layout.
   if (mReplyHeadTextView.getVisibility() == View.VISIBLE) {
       outState.putBoolean("reply_visible", true);
       outState.putString("reply_text", 
                      mReplyTextView.getText().toString());
   }
}

Die onCreate()-Methode:

@Override
protected void onCreate(Bundle savedInstanceState) {
   super.onCreate(savedInstanceState);
   setContentView(R.layout.activity_main);

   Log.d(LOG_TAG, "-------");
   Log.d(LOG_TAG, "onCreate");

   // Initialize all the view variables.
   mMessageEditText = findViewById(R.id.editText_main);
   mReplyHeadTextView = findViewById(R.id.text_header_reply);
   mReplyTextView = findViewById(R.id.text_message_reply);

   // Restore the saved state. 
   // See onSaveInstanceState() for what gets saved.
   if (savedInstanceState != null) {
       boolean isVisible = 
                     savedInstanceState.getBoolean("reply_visible");
       // Show both the header and the message views. If isVisible is
       // false or missing from the bundle, use the default layout.
       if (isVisible) {
           mReplyHeadTextView.setVisibility(View.VISIBLE);
           mReplyTextView.setText(savedInstanceState
                                  .getString("reply_text"));
           mReplyTextView.setVisibility(View.VISIBLE);
       }
   }
}

Das abgeschlossene Projekt:

Android Studio-Projekt: TwoActivitiesLifecycle

5. Programmieren

Herausforderung: Erstellen Sie eine einfache Einkaufslisten-App mit einer Hauptaktivität für die vom Nutzer erstellte Liste und einer zweiten Aktivität für eine Liste mit gängigen Einkaufsartikeln.

  • Die Hauptaktivität sollte die zu erstellende Liste enthalten. Diese sollte aus zehn leeren TextView-Elementen bestehen.
  • Mit der Schaltfläche „Artikel hinzufügen“ bei der Hauptaktivität wird eine zweite Aktivität gestartet, die eine Liste mit gängigen Einkaufsartikeln (Käse, Reis, Äpfel usw.) enthält. Verwende Schaltflächenelemente, um die Elemente anzuzeigen.
  • Durch die Auswahl eines Elements wird der Nutzer zur Hauptaktivität zurückgeleitet und ein leeres TextView aktualisiert, sodass das ausgewählte Element enthalten ist.

Mit einem Intent werden Informationen von einer Aktivität an eine andere übergeben. Der aktuelle Status der Einkaufsliste muss gespeichert werden, wenn der Nutzer das Gerät dreht.

6. Zusammenfassung

  • Der Aktivitätslebenszyklus besteht aus einer Reihe von Status, durch die eine Aktivität migriert wird. Sie beginnt mit ihrer Erstellung und endet, wenn das Android-System die Ressourcen für diese Aktivität freigegeben hat.
  • Wenn der Nutzer von einer Aktivität zur anderen und innerhalb und außerhalb Ihrer App wechselt, wird jede Aktivität zwischen den Status im Aktivitätslebenszyklus verschoben.
  • Für jeden Status im Activity-Lebenszyklus gibt es eine entsprechende Callback-Methode, die Sie in Ihrer Activity-Klasse überschreiben können.
  • Die Lebenszyklusmethoden sind onCreate(), onStart(), onPause(), onReboot(), onResume(), onStop(), onDestroy().
  • Durch das Überschreiben einer Lebenszyklus-Callback-Methode können Sie ein Verhalten hinzufügen, das auftritt, wenn Ihre Aktivität in diesen Status übergeht.
  • Sie können Ihren Klassen in Android Studio grundlegende Überschreibungsmethoden mit Code > Überschreiben hinzufügen.
  • Bei Änderungen der Gerätekonfiguration, z. B. bei der Rotation, wird die Aktivität gelöscht und neu erstellt, als wäre sie neu.
  • Ein Teil des Aktivitätsstatus wird bei einer Konfigurationsänderung beibehalten, einschließlich der aktuellen Werte von EditText-Elementen. Alle anderen Daten müssen Sie explizit selbst speichern.
  • Speichern Sie den Status der Activity-Instanz in der onSaveInstanceState()-Methode.
  • Instanzstatusdaten werden als einfache Schlüssel/Wert-Paare in einem Bundle gespeichert. Mit den Bundle-Methoden können Sie Daten in das Bundle einfügen und wieder daraus entfernen.
  • Stellen Sie den Instanzstatus in der bevorzugten Methode "onCreate()" oder mit "onRestoreInstanceState()" wieder her. Zurück