Cykl życia aktywności Androida - do czego służą wszystkie te metody?

Jaki jest cykl życia działania Androida? Dlaczego tak wiele podobnych metod brzmiące ( onCreate(), onStart(), onResume()) o nazwie podczas inicjalizacji i wielu innych ( onPause(), onStop(), onDestroy()) o nazwie na końcu?

Kiedy wywoływane są te metody i jak należy je właściwie stosować?

Zobacz to w cyklu życia aktywności (w Android Developers).

onCreate () :

Wywoływany przy pierwszym utworzeniu działania. W tym miejscu powinieneś wykonać całą normalną konfigurację statyczną: tworzyć widoki, wiązać dane z listami itp. Ta metoda zapewnia również pakiet zawierający wcześniej zablokowany stan działania, jeśli taki był. Zawsze następuje onStart ().

onRestart () :

Wywoływany po zatrzymaniu aktywności przed jej ponownym uruchomieniem. Zawsze po nim następuje onStart ()

onStart () :

Wywoływany, gdy aktywność staje się widoczna dla użytkownika. Po nim następuje onResume (), jeśli aktywność pojawia się na pierwszym planie.

onResume () :

Wywoływany, gdy aktywność zacznie współdziałać z użytkownikiem. W tym momencie twoja aktywność znajduje się na górze stosu aktywności, a dane wejściowe użytkownika są do niej kierowane. Zawsze następuje onPause ().

onPause () :

Wywoływany jako część cyklu życia aktywności, gdy aktywność przechodzi w tło, ale nie została (jeszcze) zabita. Odpowiednik onResume (). Gdy działanie B zostanie uruchomione przed działaniem A, to wywołanie zwrotne zostanie wywołane na A. B nie zostanie utworzone, dopóki nie powróci funkcja onPause () A, więc pamiętaj, aby nie robić tutaj nic długiego.

onStop () :

Wywoływany, gdy użytkownik nie jest już widoczny dla użytkownika. Następnie otrzymasz albo onRestart (), onDestroy (), albo nic, w zależności od późniejszej aktywności użytkownika. Zauważ, że ta metoda może nigdy nie zostać wywołana, w sytuacjach braku pamięci, gdy system nie ma wystarczającej ilości pamięci, aby utrzymać proces działania po wywołaniu metody onPause ().

onDestroy () :

Ostatnie połączenie, które otrzymasz, zanim Twoja aktywność zostanie zniszczona. Może się to zdarzyć albo dlatego, że działanie się kończy (ktoś nazywa się na nim finish (), albo dlatego, że system tymczasowo niszczy to wystąpienie działania, aby zaoszczędzić miejsce). Możesz rozróżnić> te dwa scenariusze za pomocą metody isFinishing ().

Przy pierwszym ładowaniu działania zdarzenia są wywoływane w następujący sposób:

onCreate()
onStart()
onResume()

Po kliknięciu przycisku Telefon aktywność przechodzi w tło i wywoływane są następujące zdarzenia:

onPause()
onStop()

Wyjdź z telefonu, a wywołane zostaną poniższe zdarzenia:

onRestart()
onStart()
onResume()

Po kliknięciu przycisku Wstecz LUB próby zakończenia () działania zdarzenia są wywoływane w następujący sposób:

onPause()
onStop()
onDestroy()

Stany aktywności

System operacyjny Android korzysta z kolejki priorytetowej, aby pomóc w zarządzaniu działaniami uruchomionymi na urządzeniu. W zależności od stanu, w którym znajduje się określona aktywność Androida, zostanie przypisany określony priorytet w systemie operacyjnym. Ten priorytetowy system pomaga Androidowi zidentyfikować nieużywane działania, umożliwiając systemowi operacyjnemu odzyskanie pamięci i zasobów. Poniższy diagram ilustruje stany, przez które może przejść aktywność w trakcie jej trwania:

Stany te można podzielić na trzy główne grupy w następujący sposób:

Aktywne lub uruchomione - działania są uważane za aktywne lub uruchomione, jeśli znajdują się na pierwszym planie, znane również jako szczyt stosu działań. Jest to uważane za działanie o najwyższym priorytecie na stosie działań Androida i jako takie zostanie zabite przez system operacyjny tylko w ekstremalnych sytuacjach, na przykład gdy działanie będzie próbowało zużywać więcej pamięci niż jest dostępne na urządzeniu, ponieważ może to spowodować, że interfejs użytkownika przestać reagować.

Wstrzymane - gdy urządzenie przechodzi w tryb uśpienia lub aktywność jest nadal widoczna, ale częściowo ukryta przez nową, niedokończoną lub przezroczystą aktywność, uznaje się ją za wstrzymaną. Wstrzymane działania są nadal aktywne, to znaczy zachowują wszystkie informacje o stanie i członkach oraz pozostają podłączone do menedżera okien. Jest to uważane za drugie działanie o najwyższym priorytecie w stosie Aktywności Androida i jako takie zostanie zabite przez system operacyjny tylko wtedy, gdy zabicie tego działania spełni wymagania dotyczące zasobów potrzebne do utrzymania stabilności i działania Aktywnej / Działającej Aktywności.

Zatrzymane - działania całkowicie zasłonięte przez inne działanie są uważane za zatrzymane lub w tle. Zatrzymane działania nadal próbują zachować swój stan i informacje o członkach tak długo, jak to możliwe, ale zatrzymane działania są uważane za najniższy priorytet trzech stanów i jako taki system operacyjny najpierw zabije działania w tym stanie, aby spełnić wymagania dotyczące zasobów działań o wyższym priorytecie.

* Przykładowa aktywność w celu zrozumienia cyklu życia **

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

Aktywność ma sześć stanów

• Utworzony
• Zaczęło się
• Wznów
• Wstrzymany
• Zatrzymany
• Zniszczony

Cykl życia aktywności obejmuje siedem metod

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

Sytuacje

• Po otwarciu aplikacji

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

• Po naciśnięciu przycisku Wstecz i wyjściu z aplikacji

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

• Po naciśnięciu przycisku Home

  onPaused() --> onStop()

• Po naciśnięciu przycisku Home po ponownym otwarciu aplikacji z listy ostatnich zadań lub kliknięciu ikony

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

• Po otwarciu aplikacji inna aplikacja z paska powiadomień lub otwórz ustawienia

  onPaused() --> onStop()

• Naciśnięty przycisk Wstecz z innej aplikacji lub ustawień, a następnie użyty, może zobaczyć naszą aplikację

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

• Po otwarciu dowolnego okna dialogowego na ekranie

  onPause()

• Po zamknięciu okna dialogowego lub przycisku Wstecz z okna dialogowego

  onResume()

• Dowolny telefon dzwoni i użytkownik w aplikacji

  onPause() --> onResume() 

• Gdy użytkownik naciśnie przycisk odbierania telefonu

  onPause()

• Po zakończeniu połączenia

  onResume()

• Gdy ekran telefonu jest wyłączony

  onPaused() --> onStop()

• Gdy ekran jest ponownie włączony

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

Całe zamieszanie jest spowodowane tym, że Google wybrało nieintuicyjne nazwy zamiast czegoś w następujący sposób:

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] 

Diagram aktywności można interpretować jako:

CYKL ŻYCIA ANDROIDA

Istnieje siedem metod zarządzania cyklem życia aplikacji na Androida:

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

Odpowiedz na jakie są wszystkie te metody:

Weźmy prosty scenariusz, w którym wiedza w jakiej kolejności są nazywane te metody pomoże nam wyjaśnić, dlaczego są one stosowane.

• Załóżmy, że korzystasz z aplikacji kalkulatora. Trzy metody są wywoływane kolejno w celu uruchomienia aplikacji.

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

• Gdy korzystam z aplikacji kalkulatora, nagle pojawia się połączenie. Aktywność kalkulatora przechodzi w tło i mówi inna aktywność. Postępowanie z wezwaniem pojawia się na pierwszym planie, a teraz dwie metody są wywoływane kolejno.

onPause() - - -> onStop()

• Teraz powiedzmy, że kończę rozmowę przez telefon, aktywność kalkulatora pojawia się na pierwszym planie z tła, więc trzy metody są wywoływane kolejno.

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

• Na koniec powiedzmy, że wykonałem wszystkie zadania w aplikacji kalkulatora i chcę ją zamknąć. Kolejne dwie metody są wywoływane kolejno.

onStop() - - -> onDestroy()

Istnieją cztery stany, które mogą istnieć:

• Stan początkowy
• Running State
• Stan wstrzymany
• Stan zatrzymania

Stan początkowy obejmuje:

Tworzenie nowego procesu Linux, przydzielanie nowej pamięci dla nowych obiektów interfejsu użytkownika i konfigurowanie całego ekranu. Więc większość pracy jest tutaj zaangażowana.

Stan pracy obejmuje:

Jest to aktywność (stan), która jest aktualnie wyświetlana na ekranie. Sam ten stan obsługuje takie rzeczy, jak pisanie na ekranie oraz dotykanie i klikanie przycisków.

Stan wstrzymany obejmuje:

Gdy aktywność nie znajduje się na pierwszym planie, a zamiast tego jest w tle, mówi się, że aktywność jest wstrzymana.

Stan zatrzymania obejmuje:

Zatrzymaną aktywność można kupić na pierwszym planie tylko poprzez jej ponowne uruchomienie, a także można ją zniszczyć w dowolnym momencie.

Menedżer działań obsługuje wszystkie te stany w taki sposób, aby wrażenia użytkownika i wydajność były zawsze najlepsze, nawet w scenariuszach, w których nowe działanie jest dodawane do istniejących działań

Podoba mi się to pytanie i odpowiedzi na nie, ale do tej pory nie obejmuje rzadziej używanych wywołań zwrotnych, takich jak onPostCreate () lub onPostResume () . Steve Pomeroy próbował schematu, w tym tych i ich związku z cyklem życia fragmentów Androida , na https://github.com/xxv/android-lifecycle . Poprawiłem duży schemat Steve'a, aby zawierał tylko część Aktywność, i sformatowałem go do wydruku jednostronicowego w formacie listowym. Opublikowałem go jako tekstowy plik PDF na stronie https://github.com/code-read/android-lifecycle/blob/master/AndroidActivityLifecycle1.pdf, a poniżej znajduje się jego obraz:

Na stronie programistów Androida

onPause ():

Wywoływany, gdy system ma rozpocząć wznawianie poprzedniej aktywności. Jest to zwykle używane do zatwierdzania niezapisanych zmian w trwałych danych, zatrzymywania animacji i innych rzeczy, które mogą pochłaniać procesor itp. Implementacje tej metody muszą być bardzo szybkie, ponieważ następne działanie nie zostanie wznowione, dopóki ta metoda nie powróci. Po nim następuje albo onResume (), jeśli aktywność powraca do przodu, albo onStop (), jeśli staje się niewidoczna dla użytkownika.

onStop ():

Wywoływany, gdy działanie nie jest już widoczne dla użytkownika, ponieważ zostało wznowione inne działanie i obejmuje je. Może się to zdarzyć albo dlatego, że rozpoczyna się nowe działanie, przed nim pojawia się istniejące, albo jest niszczone. Następnie następuje albo onRestart (), jeśli ta aktywność wraca do interakcji z użytkownikiem, albo onDestroy (), jeśli ta aktywność zanika.

Załóżmy teraz, że są trzy Działania i przejdziesz od A do B, wtedy onPauza A zostanie wywołana teraz z B do C, a następnie onPauza B i onStop A zostanie wywołana.

Wstrzymana aktywność zostaje wznowiona, a Stopped - ponownie uruchomiona.

Kiedy zadzwonisz this.finish(), onPause-onStop-onDestroy zostanie wywołany. Najważniejszą rzeczą do zapamiętania jest: wstrzymane działania zostają zatrzymane, a działanie zatrzymane zostaje zniszczone, gdy Android wymaga pamięci do innych operacji.

Mam nadzieję, że to wystarczająco jasne.

Dodanie kilku dodatkowych informacji do wysoko ocenianej odpowiedzi (Dodano dodatkową sekcję KILLABLE i kolejny zestaw metod, które zostaną wywołane w cyklu życia):

Źródło: developer.android.com

Uwaga „ Możliwy do zabicia kolumnę ” w powyższej tabeli - dla metod oznaczonych jako możliwe do wywołania, po zwróceniu tej metody proces hostujący działanie może zostać zabity przez system w dowolnym momencie bez wykonania kolejnego wiersza kodu.

Z tego powodu należy użyć tej onPause()metody do zapisania wszelkich trwałych danych (takich jak zmiany wprowadzone przez użytkownika) do pamięci. Ponadto metoda onSaveInstanceState(Bundle)jest wywoływana przed umieszczeniem działania w takim stanie tła, umożliwiając zapisanie dowolnego stanu instancji dynamicznej w danym działaniu do podanego Bundle, który można później odebrać, onCreate(Bundle)jeśli działanie musi zostać odtworzone.

Należy pamiętać, że ważne jest zapisywanie trwałych danych onPause()zamiast, onSaveInstanceState(Bundle)ponieważ nie są one częścią wywołań zwrotnych cyklu życia, więc nie będą wywoływane w każdej sytuacji, jak opisano w jego dokumentacji.

Chciałbym dodać jeszcze kilka metod. Nie są one wymienione jako metody cyklu życia, ale będą wywoływane podczas cyklu życia, w zależności od niektórych warunków. W zależności od wymagań może być konieczne zaimplementowanie tych metod w aplikacji w celu prawidłowej obsługi stanu.

onPostCreate(Bundle savedInstanceState)

Wywoływany, gdy rozruch aktywności jest zakończony (po onStart()i onRestoreInstanceState(Bundle)został wywołany).

onPostResume()

Wywoływany, gdy wznawianie aktywności jest zakończone (po onResume()wywołaniu).

onSaveInstanceState(Bundle outState)

Wywoływany w celu pobrania stanu instancji z działania przed zabiciem, aby można go było przywrócić w onCreate(Bundle)lub onRestoreInstanceState(Bundle)(pakiet wypełniony tą metodą zostanie przekazany do obu).

onRestoreInstanceState(Bundle savedInstanceState)

Ta metoda jest wywoływana po onStart()ponownym zainicjowaniu działania z wcześniej zapisanego stanu, podanego tutaj w savedInstanceState.

Mój kod aplikacji przy użyciu wszystkich tych metod:

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

Aktywność logowania:

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

wyjście: (Przed pauzą)

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

wyjście: (Po wznowieniu z pauzy)

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

Zauważ, że onPostResume()jest wywoływany, chociaż nie jest cytowany jako metoda cyklu życia.

Uruchomiłem niektóre dzienniki zgodnie z powyższymi odpowiedziami i oto wynik:

Aktywność początkowa

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: 

Zatrzymywanie aktywności

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: 

Moim osobistym zdaniem tylko dwa są wymagane na Start i OnStop.

onResume wydaje się być w każdym przypadku powrotu, a onPauza w każdym przypadku opuszczenia (z wyjątkiem zamknięcia aplikacji).