Lebenszyklus von Android-Aktivitäten - wofür sind all diese Methoden?

Was ist der Lebenszyklus einer Android-Aktivität? Warum sind so viele ähnlich klingendes Verfahren ( onCreate(), onStart(), onResume()) während der Initialisierung genannt, und so viele andere ( onPause(), onStop(), onDestroy()) am Ende genannt?

Wann werden diese Methoden aufgerufen und wie sollten sie richtig angewendet werden?

Sehen Sie es im Aktivitätslebenszyklus (bei Android-Entwicklern).

onCreate () :

Wird aufgerufen, wenn die Aktivität erstellt wird. Hier sollten Sie alle normalen statischen Einstellungen vornehmen: Ansichten erstellen, Daten an Listen binden usw. Mit dieser Methode erhalten Sie auch ein Bundle, das den zuvor eingefrorenen Status der Aktivität enthält, sofern vorhanden. Immer gefolgt von onStart ().

onRestart () :

Wird aufgerufen, nachdem Ihre Aktivität gestoppt wurde, bevor sie erneut gestartet wird. Immer gefolgt von onStart ()

onStart () :

Wird aufgerufen, wenn die Aktivität für den Benutzer sichtbar wird. Gefolgt von onResume (), wenn die Aktivität in den Vordergrund tritt.

onResume () :

Wird aufgerufen, wenn die Aktivität mit dem Benutzer interagiert. Zu diesem Zeitpunkt befindet sich Ihre Aktivität ganz oben im Aktivitätsstapel, und die Benutzereingaben werden dorthin geleitet. Immer gefolgt von onPause ().

onPause () :

Wird als Teil des Aktivitätslebenszyklus aufgerufen, wenn eine Aktivität in den Hintergrund tritt, aber (noch) nicht getötet wurde. Das Gegenstück zu onResume (). Wenn Aktivität B vor Aktivität A gestartet wird, wird dieser Rückruf für A aufgerufen. B wird erst erstellt, wenn onPause () von A zurückgegeben wird. Führen Sie daher hier keine längeren Schritte aus.

onStop () :

Wird aufgerufen, wenn Sie für den Benutzer nicht mehr sichtbar sind. Abhängig von der späteren Benutzeraktivität erhalten Sie als Nächstes entweder onRestart (), onDestroy () oder nichts. Beachten Sie, dass diese Methode in Situationen mit wenig Arbeitsspeicher, in denen das System nicht über genügend Arbeitsspeicher verfügt, um den Prozess Ihrer Aktivität nach dem Aufruf der Methode onPause () auszuführen, möglicherweise nie aufgerufen wird.

onDestroy () :

Der letzte Anruf, den Sie erhalten, bevor Ihre Aktivität zerstört wird. Dies kann entweder passieren, weil die Aktivität beendet wird (jemand, der als finish () bezeichnet wird, oder weil das System diese Instanz der Aktivität vorübergehend zerstört, um Platz zu sparen. Mit der Methode isFinishing () können Sie zwischen diesen beiden Szenarien unterscheiden.

Wenn die Aktivität zum ersten Mal geladen wird, werden die Ereignisse wie folgt aufgerufen:

onCreate()
onStart()
onResume()

Wenn Sie auf die Schaltfläche Telefon klicken, wird die Aktivität in den Hintergrund gestellt und die folgenden Ereignisse werden aufgerufen:

onPause()
onStop()

Beenden Sie den Telefonwähler und die folgenden Ereignisse werden aufgerufen:

onRestart()
onStart()
onResume()

Wenn Sie auf die Schaltfläche Zurück klicken ODER versuchen, die Aktivität zu beenden (), werden die Ereignisse wie folgt aufgerufen:

onPause()
onStop()
onDestroy()

Aktivitätszustände

Das Android-Betriebssystem verwendet eine Prioritätswarteschlange, um die Verwaltung der auf dem Gerät ausgeführten Aktivitäten zu unterstützen. Abhängig vom Status einer bestimmten Android-Aktivität wird ihr innerhalb des Betriebssystems eine bestimmte Priorität zugewiesen. Dieses Prioritätssystem hilft Android dabei, Aktivitäten zu identifizieren, die nicht mehr verwendet werden, und ermöglicht es dem Betriebssystem, Speicher und Ressourcen zurückzugewinnen. Das folgende Diagramm zeigt die Zustände, die eine Aktivität während ihrer Lebensdauer durchlaufen kann:

Diese Zustände können wie folgt in drei Hauptgruppen unterteilt werden:

Aktiv oder laufend - Aktivitäten gelten als aktiv oder laufend, wenn sie im Vordergrund stehen, auch als oberster Punkt des Aktivitätsstapels bezeichnet. Dies wird als Aktivität mit der höchsten Priorität im Android-Aktivitätsstapel angesehen und wird daher nur in extremen Situationen vom Betriebssystem beendet, z. B. wenn die Aktivität versucht, mehr Speicher zu verwenden, als auf dem Gerät verfügbar ist, da dies dazu führen kann, dass die Benutzeroberfläche dies tut nicht mehr reagieren.

Angehalten - Wenn das Gerät in den Ruhezustand wechselt oder eine Aktivität noch sichtbar ist, aber teilweise durch eine neue, nicht vollständige oder transparente Aktivität ausgeblendet wird, gilt die Aktivität als angehalten. Angehaltene Aktivitäten sind noch aktiv, dh sie verwalten alle Status- und Mitgliederinformationen und bleiben dem Fenstermanager zugeordnet. Dies wird als Aktivität mit der zweithöchsten Priorität im Android-Aktivitätsstapel angesehen und als solche nur vom Betriebssystem beendet, wenn das Beenden dieser Aktivität die Ressourcenanforderungen erfüllt, die erforderlich sind, um die aktive / laufende Aktivität stabil und reaktionsschnell zu halten.

Gestoppt - Aktivitäten, die durch eine andere Aktivität vollständig verdeckt sind, gelten als gestoppt oder im Hintergrund. Gestoppte Aktivitäten versuchen immer noch, ihre Status- und Mitgliedsinformationen so lange wie möglich beizubehalten. Gestoppte Aktivitäten werden jedoch als die niedrigste Priorität der drei Status angesehen. Daher beendet das Betriebssystem Aktivitäten in diesem Status zuerst, um die Ressourcenanforderungen zu erfüllen von Aktivitäten mit höherer Priorität.

* Beispielaktivität zum Verständnis des Lebenszyklus **

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");
    }
}

Aktivität hat sechs Zustände

• Erstellt
• Gestartet
• Wieder aufgenommen
• Pause
• Gestoppt
• Zerstört

Der Aktivitätslebenszyklus umfasst sieben Methoden

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

Situationen

• Beim Öffnen der App

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

• Wenn Sie die Zurück-Taste gedrückt haben, beenden Sie die App

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

• Wenn die Home-Taste gedrückt wird

  onPaused() --> onStop()

• Nachdem Sie die Home-Taste gedrückt haben, öffnen Sie die App erneut aus der Liste der letzten Aufgaben oder klicken Sie auf das Symbol

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

• Beim Öffnen einer App wird eine andere App über die Benachrichtigungsleiste oder die Einstellungen geöffnet

  onPaused() --> onStop()

• Wenn Sie die Zurück-Taste einer anderen App oder der dann verwendeten Einstellungen drücken, wird unsere App angezeigt

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

• Wenn ein Dialog auf dem Bildschirm geöffnet wird

  onPause()

• Nachdem Sie den Dialog oder die Schaltfläche "Zurück" aus dem Dialog entfernt haben

  onResume()

• Jedes Telefon klingelt und Benutzer in der App

  onPause() --> onResume() 

• Wenn der Benutzer die Antworttaste des Telefons gedrückt hat

  onPause()

• Nach Anrufende

  onResume()

• Wenn der Bildschirm des Telefons ausgeschaltet ist

  onPaused() --> onStop()

• Wenn der Bildschirm wieder eingeschaltet wird

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

Die gesamte Verwirrung wird dadurch verursacht, dass Google nicht-intuitive Namen anstelle von etwas wie folgt gewählt hat:

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] 

Das Aktivitätsdiagramm kann wie folgt interpretiert werden:

ANDROID LEBENSZYKLUS

Es gibt sieben Methoden, die den Lebenszyklus einer Android-Anwendung verwalten:

• onCreate ()
• am Start()
• auf Wiederaufnahme()
• onRestart ()
• onPause ()
• onStop ()
• onDestroy ()

Antwort für was sind all diese Methoden für:

Nehmen wir ein einfaches Szenario, in dem wir wissen, in welcher Reihenfolge diese Methoden aufgerufen werden, um zu verdeutlichen, warum sie verwendet werden.

• Angenommen, Sie verwenden eine Taschenrechner-App. Drei Methoden werden nacheinander aufgerufen, um die App zu starten.

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

• Wenn ich die Rechner-App benutze, kommt plötzlich ein Anruf. Die Taschenrechneraktivität tritt in den Hintergrund und eine andere Aktivität sagt. Der Umgang mit dem Aufruf steht im Vordergrund, und jetzt werden zwei Methoden nacheinander aufgerufen.

onPause() - - -> onStop()

• Angenommen, ich beende das Gespräch am Telefon, die Taschenrechneraktivität tritt im Hintergrund in den Vordergrund, sodass drei Methoden nacheinander aufgerufen werden.

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

• Angenommen, ich habe alle Aufgaben in der Taschenrechner-App abgeschlossen und möchte die App beenden. Weitere zwei Methoden werden nacheinander aufgerufen.

onStop() - - -> onDestroy()

Es gibt vier Zustände, in denen eine Aktivität möglicherweise existieren kann:

• Ausgangszustand
• Betriebszustand
• Angehaltener Zustand
• Angehaltener Zustand

Der Ausgangszustand beinhaltet:

Erstellen eines neuen Linux-Prozesses, Zuweisen von neuem Speicher für die neuen UI-Objekte und Einrichten des gesamten Bildschirms. Der größte Teil der Arbeit ist hier involviert.

Der Betriebszustand beinhaltet:

Es ist die Aktivität (Status), die derzeit auf dem Bildschirm angezeigt wird. Dieser Status allein behandelt Dinge wie das Tippen auf dem Bildschirm und das Berühren und Klicken von Schaltflächen.

Der angehaltene Zustand beinhaltet:

Wenn sich eine Aktivität nicht im Vordergrund und stattdessen im Hintergrund befindet, wird die Aktivität als angehalten bezeichnet.

Der gestoppte Zustand beinhaltet:

Eine gestoppte Aktivität kann nur durch Neustart in den Vordergrund gekauft und zu jedem Zeitpunkt zerstört werden.

Der Aktivitätsmanager behandelt alle diese Zustände so, dass die Benutzererfahrung und Leistung auch in Szenarien, in denen die neue Aktivität zu den vorhandenen Aktivitäten hinzugefügt wird, immer optimal ist

Ich mag diese Frage und die Antworten darauf, aber bisher werden weniger häufig verwendete Rückrufe wie onPostCreate () oder onPostResume () nicht behandelt . Steve Pomeroy hat unter https://github.com/xxv/android-lifecycle ein Diagramm versucht, das diese und ihre Beziehung zum Fragment- Lebenszyklus von Android enthält . Ich habe Steves großes Diagramm so überarbeitet, dass es nur den Aktivitätsteil enthält, und es für den einseitigen Ausdruck im Letter-Format formatiert. Ich habe es als Text-PDF unter https://github.com/code-read/android-lifecycle/blob/master/AndroidActivityLifecycle1.pdf veröffentlicht und unten ist das Bild:

Auf der Android-Entwicklerseite

onPause ():

Wird aufgerufen, wenn das System eine vorherige Aktivität wieder aufnehmen möchte. Dies wird normalerweise verwendet, um nicht gespeicherte Änderungen an persistenten Daten festzuschreiben, Animationen zu stoppen und andere Dinge, die möglicherweise CPU verbrauchen usw. Die Implementierung dieser Methode muss sehr schnell erfolgen, da die nächste Aktivität erst fortgesetzt wird, wenn diese Methode zurückgegeben wird. Gefolgt von onResume (), wenn die Aktivität wieder in den Vordergrund zurückkehrt, oder onStop (), wenn sie für den Benutzer unsichtbar wird.

onStop ():

Wird aufgerufen, wenn die Aktivität für den Benutzer nicht mehr sichtbar ist, weil eine andere Aktivität wieder aufgenommen wurde und diese abdeckt. Dies kann entweder passieren, weil eine neue Aktivität gestartet wird, eine vorhandene vor diese gestellt wird oder diese zerstört wird. Gefolgt von onRestart (), wenn diese Aktivität zurückkehrt, um mit dem Benutzer zu interagieren, oder onDestroy (), wenn diese Aktivität beendet wird.

Angenommen, es gibt drei Aktivitäten und Sie gehen von A nach B, dann wird onPause von A jetzt von B nach C aufgerufen, dann wird onPause von B und onStop von A aufgerufen.

Die angehaltene Aktivität wird fortgesetzt und die gestoppte Aktivität wird neu gestartet.

Wenn Sie aufrufen this.finish(), wird onPause-onStop-onDestroy aufgerufen. Das Wichtigste, an das Sie sich erinnern sollten, ist: Angehaltene Aktivitäten werden gestoppt und eine angehaltene Aktivität wird zerstört, wenn Android Speicher für andere Vorgänge benötigt.

Ich hoffe es ist klar genug.

Hinzufügen weiterer Informationen zu hoch bewerteten Antworten (Zusätzlicher Abschnitt von KILLABLE und nächste Methoden, die im Lebenszyklus aufgerufen werden sollen) hinzugefügt:

Quelle: developer.android.com

Beachten Sie die Spalte " Killable " in der obigen Tabelle. Für Methoden, die als Killable markiert sind, kann der Prozess, der die Aktivität hostet, jederzeit vom System abgebrochen werden, ohne dass eine weitere Zeile des Codes ausgeführt wird.

Aus diesem Grund sollten Sie die onPause()Methode verwenden, um persistente Daten (z. B. Benutzeränderungen) in den Speicher zu schreiben. Darüber hinaus wird die Methode onSaveInstanceState(Bundle)aufgerufen, bevor die Aktivität in einen solchen Hintergrundstatus versetzt wird. Auf diese Weise können Sie jeden dynamischen Instanzstatus in Ihrer Aktivität in dem angegebenen Status speichern Bundleund später empfangen, onCreate(Bundle)wenn die Aktivität neu erstellt werden muss.

Beachten Sie, dass es wichtig ist, persistente Daten zu speichern, onPause()anstatt onSaveInstanceState(Bundle)dass letztere nicht Teil der Lebenszyklus-Rückrufe sind und daher nicht in jeder Situation aufgerufen werden, wie in der Dokumentation beschrieben.

Ich möchte noch einige Methoden hinzufügen. Diese sind nicht als Lebenszyklusmethoden aufgeführt, werden jedoch abhängig von bestimmten Bedingungen während des Lebenszyklus aufgerufen. Abhängig von Ihren Anforderungen müssen Sie diese Methoden möglicherweise in Ihrer Anwendung implementieren, um den Status ordnungsgemäß zu behandeln.

onPostCreate(Bundle savedInstanceState)

Wird aufgerufen, wenn der Aktivitätsstart abgeschlossen ist (nachdem onStart()und onRestoreInstanceState(Bundle)aufgerufen wurden).

onPostResume()

Wird aufgerufen, wenn die Wiederaufnahme der Aktivität abgeschlossen ist (nachdem onResume()sie aufgerufen wurde).

onSaveInstanceState(Bundle outState)

Wird aufgerufen, um den Status pro Instanz aus einer Aktivität abzurufen, bevor er beendet wird, damit der Status in onCreate(Bundle)oder wiederhergestellt werden kann onRestoreInstanceState(Bundle)(das mit dieser Methode aufgefüllte Bundle wird an beide übergeben).

onRestoreInstanceState(Bundle savedInstanceState)

Diese Methode wird aufgerufen, onStart()wenn die Aktivität aus einem zuvor gespeicherten Zustand neu initialisiert wird (siehe hier) savedInstanceState.

Mein Anwendungscode mit all diesen Methoden:

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);
    }
}

Anmeldeaktivität:

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();
    }
}

Ausgabe: (Vor Pause)

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

Ausgabe: (Nach Wiederaufnahme der Pause)

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

Beachten Sie, dass dies onPostResume()aufgerufen wird, obwohl es nicht als Lebenszyklusmethode angegeben ist.

Ich führe einige Protokolle gemäß den obigen Antworten aus und hier ist die Ausgabe:

Aktivität starten

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: 

Beenden der Aktivität

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: 

Meiner persönlichen Meinung nach sind nur zwei onStart und onStop erforderlich.

onResume scheint in jedem Fall des Zurückkommens und onPause in jedem Fall des Verlassens zu sein (außer beim Schließen der App).