Aktivitätslebenszyklus und -status verwenden

1. Willkommen

Dieses praktische Codelab ist Teil von Modul 1: Erste Schritte im Kurs „Grundlagen der Android-Entwicklung (Version 2)“. Sie profitieren am meisten von diesem Kurs, wenn Sie die Codelabs der Reihe nach durcharbeiten:

  • Eine vollständige Liste der Codelabs im Kurs finden Sie unter Codelabs für Android-Entwicklergrundlagen (Version 2).
  • Details zum Kurs, einschließlich Links zu allen Kapiteln, Apps und Folien zu den einzelnen Konzepten, finden Sie unter Android Developer Fundamentals (Version 2).

Einführung

In diesem praktischen Teil erfahren Sie mehr über den Aktivitätszyklus. Der Lebenszyklus ist die Gesamtheit der Zustände, in denen sich eine Aktivität während ihrer gesamten Lebensdauer befinden kann, vom Erstellen bis zum Löschen und Zurückfordern der Ressourcen durch das System. Wenn Nutzer zwischen Aktivitäten in Ihrer App wechseln (sowie in und aus Ihrer App), wechseln die Aktivitäten zwischen verschiedenen Zuständen in ihrem Lebenszyklus.

IDouble trouble

Jede Phase im Lebenszyklus einer Aktivität hat eine entsprechende Rückrufmethode: onCreate(), onStart(), onPause() usw. Wenn der Status einer Aktivität geändert wird, wird die zugehörige Callback-Methode aufgerufen. Eine dieser Methoden haben Sie bereits kennengelernt: onCreate(). Wenn Sie eine der Lebenszyklus-Callback-Methoden in Ihren Aktivitätsklassen ü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 der Gerätekonfiguration ändern, z. B. wenn der Nutzer das Gerät von Hoch- auf Querformat dreht. Wenn diese Konfigurationsänderungen auftreten, wird die Aktivität gelöscht und im Standardzustand neu erstellt. Der Nutzer verliert möglicherweise Informationen, die er in die Aktivität eingegeben hat. Um Ihre Nutzer nicht zu verwirren, ist es wichtig, dass Sie Ihre App so entwickeln, dass unerwartete Datenverluste vermieden werden. Später in diesem praktischen Teil experimentieren Sie mit Konfigurationsänderungen und erfahren, wie Sie den Status einer Aktivität als Reaktion auf Änderungen der Gerätekonfiguration und andere Lebenszyklusereignisse von Aktivitäten beibehalten.

In diesem praktischen Teil fügen Sie der App „Zwei Aktivitäten“ Protokollierungsanweisungen hinzu und beobachten Änderungen am Aktivitätszyklus, während Sie die App verwenden. Anschließend arbeiten Sie mit diesen Änderungen und untersuchen, wie Sie Nutzereingaben unter diesen Bedingungen verarbeiten.

Vorbereitung

Sie sollten Folgendes können:

  • Erstellen und ausführen Sie ein App-Projekt in Android Studio.
  • Fügen Sie Ihrer App Log-Anweisungen hinzu und rufen Sie diese Logs im Logcat-Bereich auf.
  • Sie sollten Aktivitäten und Absichten verstehen und mit ihnen arbeiten können und sich sicher in der Interaktion mit ihnen fühlen.

Lerninhalte

  • So funktioniert der Aktivitätslebenszyklus
  • Wenn eine Aktivität gestartet, pausiert, angehalten und zerstört wird.
  • Lebenszyklus-Callback-Methoden im Zusammenhang mit Aktivitätsänderungen
  • Die Auswirkungen von Aktionen (z. B. Konfigurationsänderungen), die zu Lebenszyklusereignissen für Aktivitäten führen können.
  • So bewahren Sie den Aktivitätsstatus über Lebenszyklusereignisse hinweg bei.

Aufgaben

  • Fügen Sie der App TwoActivities aus dem vorherigen praktischen Teil Code hinzu, um die verschiedenen Callbacks des Aktivitätslebenszyklus zu implementieren und Protokollierungsanweisungen einzufügen.
  • Beobachten Sie die Statusänderungen, während Ihre App ausgeführt wird und Sie mit den einzelnen Aktivitäten in Ihrer App interagieren.
  • Ändern Sie Ihre App so, dass der Instanzstatus einer Aktivität beibehalten wird, die aufgrund von Nutzerverhalten oder einer Konfigurationsänderung auf dem Gerät unerwartet neu erstellt wird.

2. App-Übersicht

In diesem praktischen Teil fügen Sie der App TwoActivities etwas hinzu. Die App sieht ungefähr so aus und verhält sich ungefähr so wie im letzten Codelab. Es enthält zwei Aktivitätsimplementierungen und ermöglicht es Nutzern, zwischen ihnen zu senden. Die Änderungen, die Sie in diesem praktischen Teil an der App vornehmen, wirken sich nicht auf das sichtbare Nutzerverhalten aus.

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

In dieser Aufgabe implementieren Sie alle Rückrufmethoden des Aktivitätslebenszyklus, um bei der Aufrufung dieser Methoden Nachrichten in Logcat zu drucken. Anhand dieser Protokollmeldungen können Sie sehen, wann sich der Status des Aktivitätszyklus ändert und wie sich diese Änderungen auf Ihre App auswirken.

1.1 (Optional) Projekt „TwoActivities“ kopieren

Für die Aufgaben in diesem Praktikum ändern Sie das vorhandene Projekt TwoActivities, das Sie im letzten Praktikum erstellt haben. Wenn Sie das vorherige TwoActivities-Projekt unverändert lassen möchten, folgen Sie der Anleitung im Anhang: Dienstprogramme, um eine Kopie des Projekts zu erstellen.

1.2 Callbacks in MainActivity implementieren

  1. Öffnen Sie das Projekt „TwoActivities“ in Android Studio und dann im Bereich „Project“ > „Android“ die Datei „MainActivity“.
  2. Fügen Sie in der Methode „onCreate()“ die folgenden Protokollanweisungen hinzu:
Log.d(LOG_TAG, "-------");
Log.d(LOG_TAG, "onCreate");
  1. Fügen Sie eine Überschreibung für den Rückruf „onStart()“ mit einer Meldung in das Protokoll für dieses Ereignis hinzu:
@Override
public void onStart(){
    super.onStart();
    Log.d(LOG_TAG, "onStart");
}

Als Tastenkürzel können Sie in Android Studio „Code“ > „Methoden überschreiben“ auswählen. Es wird ein Dialogfeld mit allen möglichen Methoden angezeigt, die Sie in Ihrer Klasse überschreiben können. Wenn Sie eine oder mehrere Rückrufmethoden aus der Liste auswählen, wird eine vollständige Vorlage für diese Methoden eingefügt, einschließlich des erforderlichen Aufrufs der Superklasse.

  1. Verwenden Sie die Methode „onStart()“ als Vorlage, um die Lebenszyklus-Callbacks „onPause()“, „onRestart()“, „onResume()“, „onStop()“ und „onDestroy()“ zu implementieren.

Alle Rückrufmethoden haben dieselben Signaturen (mit Ausnahme des Namens). Wenn Sie „onStart()“ kopieren und einfügen, um diese anderen Rückrufmethoden zu erstellen, vergessen Sie nicht, den Inhalt so zu aktualisieren, dass die richtige Methode in der Superklasse aufgerufen und die richtige Methode protokolliert wird.

  1. Führen Sie die App aus.
  2. Klicken Sie unten in Android Studio auf den Tab „Logcat“, um den Logcat-Bereich aufzurufen. Sie sollten drei Protokollmeldungen sehen, die die drei Lebenszyklusstatus anzeigen, 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 die Lebenszyklus-Callback-Methoden für MainActivity implementiert haben, tun Sie dasselbe für SecondActivity.

  1. Öffnen Sie „SecondActivity“.
  2. Fügen Sie oben in 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 Protokollanweisungen 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 Protokollanweisung hinzu:
Log.d(LOG_TAG, "End SecondActivity");

1.4 Log während der Ausführung der App beobachten**

  1. Führen Sie die App aus.
  2. Klicken Sie unten in Android Studio auf den Tab „Logcat“, um den Logcat-Bereich aufzurufen.
  3. Geben Sie „Aktivitäten“ in das Suchfeld ein. Das 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 Keyword das Protokoll nur auf die Dinge filtern, die Sie interessieren.

IDouble trouble

Testen Sie Ihre App und notieren Sie sich die Lebenszyklusereignisse, die als Reaktion auf verschiedene Aktionen auftreten. Versuchen Sie insbesondere Folgendes:

  • Verwenden Sie die App wie gewohnt (senden Sie eine Nachricht, antworten Sie mit einer anderen Nachricht).
  • Mit der Schaltfläche „Zurück“ können Sie von der zweiten Aktivität zur Hauptaktivität zurückkehren.
  • Mit dem Aufwärtspfeil in der App-Leiste können Sie von der zweiten Aktivität zur Hauptaktivität zurückkehren.
  • Drehen Sie das Gerät in Ihrer App zu unterschiedlichen Zeiten sowohl bei der Haupt- als auch bei der sekundären Aktivität und beobachten Sie, was im Protokoll und auf dem Bildschirm passiert.
  • Drücken Sie die Schaltfläche „Übersicht“ (das quadratische Symbol rechts neben „Zuhause“) und schließen Sie die App (tippen Sie auf das X).
  • 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 Drehung mit der Tastenkombination „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 hinzugefügten Code in MainActivity, aber nicht die gesamte Klasse.

Die Methode onCreate():

@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 hinzugefügten Code in SecondActivity, aber nicht die gesamte Klasse.

Oben in der Klasse „SecondActivity“:

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

Die Methode „returnReply()“:

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äts-Instanz speichern und wiederherstellen

Je nach Systemressourcen und Nutzerverhalten werden Aktivitäten in Ihrer App möglicherweise viel häufiger gelöscht und neu erstellt, als Sie vielleicht denken.

Möglicherweise haben Sie dieses Verhalten im letzten Abschnitt bemerkt, 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. Die Rotation ist die häufigste Methode, aber alle Konfigurationsänderungen führen 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 das Layout der Aktivitäten bei einer Konfigurationsänderung möglicherweise auf das Standard-Layout und die ursprünglichen Werte zurückgesetzt. Ihre Nutzer verlieren dann möglicherweise ihren Fortschritt, ihre Daten oder den Status in Ihrer App.

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

Damit keine Daten in einer Aktivität verloren gehen, wenn sie unerwartet zerstört und neu erstellt wird, müssen Sie die Methode onSaveInstanceState() implementieren. Das System ruft diese Methode in Ihrer Aktivität (zwischen onPause() und onStop()) auf, wenn die Aktivität möglicherweise zerstört und neu erstellt wird.

Die Daten, die Sie im Instanzstatus speichern, beziehen sich nur auf diese Instanz dieser bestimmten Aktivität während der aktuellen App-Sitzung. Wenn Sie eine App-Sitzung beenden und eine neue starten, geht der Status der Aktivitäts-Instanz verloren und die Aktivität wird auf die Standarddarstellung zurückgesetzt. Wenn Sie Nutzerdaten zwischen App-Sitzungen speichern müssen, verwenden Sie gemeinsame Einstellungen oder eine Datenbank. Mit diesen beiden Themen werden Sie sich in einem späteren Praktikum beschäftigen.

2.1 Aktivitätsinstanzenstatus mit onSaveInstanceState() speichern

Sie haben vielleicht bemerkt, dass sich der Status der zweiten Aktivität durch das Drehen des Geräts nicht ändert. Das liegt daran, dass das Layout und der Status der zweiten Aktivität aus dem Layout und dem Intent generiert werden, die sie aktiviert haben. Auch wenn die Aktivität neu erstellt wird, ist der Intent weiterhin vorhanden und die Daten in diesem Intent werden jedes Mal verwendet, wenn die Methode „onCreate()“ in der zweiten Aktivität aufgerufen wird.

Außerdem wird in jeder Aktivität der Text, den Sie in die EditText-Elemente für Nachrichten oder Antworten eingegeben haben, bei einer Drehung des Geräts beibehalten. Das liegt daran, dass die Statusinformationen einiger der Ansichtselemente in Ihrem Layout bei Konfigurationsänderungen automatisch gespeichert werden. Der aktuelle Wert eines EditText-Elements ist einer dieser Fälle.

Der einzige Aktivitätsstatus, der Sie interessiert, sind also die TextView-Elemente für die Antwortüberschrift und den Antworttext in der Hauptaktivität. Beide TextView-Elemente sind standardmäßig ausgeblendet. Sie werden erst angezeigt, wenn Sie von der zweiten Aktivität aus eine Nachricht an die Hauptaktivität senden.

In dieser Aufgabe fügen Sie Code hinzu, um den Instanzstatus dieser beiden TextView-Elemente mit onSaveInstanceState() zu speichern.

  1. Öffnen Sie MainActivity.
  2. Fügen Sie der Aktivität diese Skelettimplementierung von onSaveInstanceState() hinzu oder verwenden Sie „Code“ > „Methoden überschreiben“, um eine Skelettüberschreibung einzufügen.
@Override
public void onSaveInstanceState(Bundle outState) {
          super.onSaveInstanceState(outState);
}
  1. Prüfen Sie, ob der Header derzeit sichtbar ist. Wenn ja, geben Sie diesen Sichtbarkeitsstatus mit der Methode „putBoolean()“ 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 der Antwortheader und der Antworttext ausgeblendet bleiben, bis eine Antwort von der zweiten Aktivität eingegangen ist. Wenn der Header sichtbar ist, gibt es Antwortdaten, die gespeichert werden müssen. Uns interessiert nur dieser Sichtbarkeitsstatus. Der tatsächliche Text der Überschrift muss nicht gespeichert werden, da er sich nie ändert.

  1. Fügen Sie in derselben Prüfung den Antworttext in das Bundle ein.
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 prüfen oder speichern. Nur der tatsächliche Text der Nachricht wird in das Status-Bundle mit dem Schlüssel „reply_text“ aufgenommen.

Sie speichern nur den Status der Elemente der Ansicht, die sich nach dem Erstellen der Aktivität ändern können. Die anderen Ansichtselemente in Ihrer App (EditText, Schaltfläche) können jederzeit aus dem Standardlayout neu erstellt werden.

Das System speichert den Status einiger Ansichtselemente, z. B. den Inhalt des EditText-Elements.

2.2 Aktivitätsinstanzenstatus in onCreate() wiederherstellen

Nachdem Sie den Status der Aktivitäts-Instanz gespeichert haben, müssen Sie ihn auch wiederherstellen, wenn die Aktivität neu erstellt wird. Sie können dies entweder in onCreate() oder durch Implementieren des Rückrufs onRestoreInstanceState() tun, der nach onStart() nach dem Erstellen der Aktivität aufgerufen wird.

In den meisten Fällen ist es am besten, den Aktivitätsstatus in onCreate() wiederherzustellen, damit die Benutzeroberfläche einschließlich des Status so schnell wie möglich verfügbar ist. Manchmal ist es praktisch, dies in onRestoreInstanceState() zu tun, nachdem die gesamte Initialisierung abgeschlossen ist, oder Unterklassen zu erlauben, zu entscheiden, ob Ihre Standardimplementierung verwendet werden soll.

  1. Fügen Sie in der Methode „onCreate()“, nachdem die View-Variablen mit „findViewById()“ initialisiert wurden, 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(). Wenn „onCreate()“ zum ersten Mal aufgerufen wird und Ihre App gestartet wird, ist das Bundle null. Beim ersten Start Ihrer App gibt es keinen vorhandenen Status. Bei nachfolgenden Aufrufen von onCreate() wird ein Bundle mit den Daten gefüllt, die Sie in onSaveInstanceState() gespeichert haben.

  1. Rufe in dieser Prüfung die aktuelle Sichtbarkeit (wahr oder falsch) aus dem Bundle mit dem Schlüssel „reply_visible“ ab.
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 im Status-Bundle der Schlüssel „reply_visible“ vorhanden ist (und „isVisible“ daher „wahr“ ist), müssen Sie den Status wiederherstellen.

  1. Machen Sie die Überschrift im Test „isVisible“ sichtbar.
mReplyHeadTextView.setVisibility(View.VISIBLE);
  1. Rufen Sie die Textantwort aus dem Bundle mit dem Schlüssel „reply_text“ ab und legen Sie fest, dass die Text-Ansicht diese Zeichenfolge anzeigen soll.
mReplyTextView.setText(savedInstanceState.getString("reply_text"));
  1. Machen Sie auch den Textview für die Antwort sichtbar:
mReplyTextView.setVisibility(View.VISIBLE);
  1. Führen Sie die App aus. Drehen Sie das Gerät oder den Emulator, um sicherzustellen, dass die Antwortnachricht (falls vorhanden) auf dem Bildschirm bleibt, 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 hinzugefügten Code in MainActivity, aber nicht die gesamte Klasse.

Die Methode onSaveInstanceState():

@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 Methode onCreate():

@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 vollständige Projekt:

Android Studio-Projekt: TwoActivitiesLifecycle

5. Programmieren

Herausforderung: Erstellen Sie eine einfache Einkaufslisten-App mit einer Hauptaktivität für die Liste, die der Nutzer erstellt, und einer zweiten Aktivität für eine Liste gängiger Einkaufsartikel.

  • Die Hauptaktivität sollte die Liste enthalten, die erstellt werden soll. Diese sollte aus zehn leeren TextView-Elementen bestehen.
  • Über die Schaltfläche „Artikel hinzufügen“ in der Hauptaktivität wird eine zweite Aktivität gestartet, die eine Liste gängiger Einkaufsartikel enthält (Käse, Reis, Äpfel usw.). Verwenden Sie Schaltflächenelemente, um die Elemente anzuzeigen.
  • Wenn der Nutzer ein Element auswählt, wird er zur Hauptaktivität zurückgeleitet und eine leere TextView wird mit dem ausgewählten Element aktualisiert.

Verwenden Sie einen Intent, um Informationen von einer Aktivität an eine andere zu übergeben. Der aktuelle Status der Einkaufsliste muss gespeichert werden, wenn der Nutzer das Gerät dreht.

6. Zusammenfassung

  • Der Aktivitätszyklus besteht aus einer Reihe von Status, die eine Aktivität durchläuft, beginnend bei der Ersterstellung und endend, wenn das Android-System die Ressourcen für diese Aktivität zurückfordert.
  • Wenn der Nutzer von einer Aktivität zur nächsten wechselt und sich innerhalb und außerhalb Ihrer App bewegt, wechselt jede Aktivität zwischen den Status im Aktivitätslebenszyklus.
  • Für jeden Status im Aktivitätslebenszyklus gibt es eine entsprechende Rückrufmethode, die Sie in Ihrer Aktivitätsklasse überschreiben können.
  • Die Lebenszyklusmethoden sind onCreate(), onStart(), onPause(), onRestart(), onResume(), onStop() und onDestroy().
  • Wenn Sie eine Lebenszyklus-Callback-Methode überschreiben, können Sie ein Verhalten hinzufügen, das ausgeführt wird, wenn Ihre Aktivität in diesen Status wechselt.
  • Sie können Ihren Klassen in Android Studio mit „Code“ > „Überschreiben“ Methoden zum Überschreiben von Vorlagen hinzufügen.
  • Änderungen an der Gerätekonfiguration, z. B. die Drehung, führen dazu, dass die Aktivität gelöscht und neu erstellt wird, als wäre sie neu.
  • Bei einer Konfigurationsänderung wird ein Teil des Aktivitätsstatus beibehalten, einschließlich der aktuellen Werte von EditText-Elementen. Alle anderen Daten müssen Sie selbst speichern.
  • Speichern Sie den Status der Aktivitäts-Instanz in der Methode onSaveInstanceState().
  • 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 abrufen.
  • Stellen Sie den Instanzstatus in onCreate() wieder her, was die bevorzugte Methode ist, oder in onRestoreInstanceState().