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


419

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ć?


17
Dlaczego to pytanie było tak wiele razy oceniane? Dlaczego nie został zamknięty?
Alexander Kulyakhtin

54
Po co zamykać pytanie z dużą liczbą głosów pozytywnych? Stackoverflow ma zły nawyk.
Dick Lucas,

12
To pytanie w stylu wiki i uważam, że powinno być dozwolone na stronie.
Mateen Ulhaq

2
@Alexander Kulyakhtin - Dlaczego warto zamknąć to pytanie? Zamiast tego powinieneś zamknąć swoje konto, jeśli nie możesz przeczytać informacji zawartych w odpowiedziach dla nowych użytkowników Androida. To pytanie jest pełne wiedzy i zamierzam zagłosować na to pytanie.
Przepełnienie stosu

Kiedy te metody nazywane są pytaniami, czego próbowaliście?
Sreekanth Karumanaghat

Odpowiedzi:


748

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

Wpisz opis zdjęcia tutaj

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

1
Więc jeśli dobrze to zrozumiałem, onStop () jest zawsze wywoływany po onPause ()?
Titouan de Bailleul

4
NIE zawsze „onStop (): Wywoływany, gdy użytkownik nie jest już widoczny dla użytkownika”
Yaqub Ahmad

2
Czy istnieje jakakolwiek szansa, że ​​zostanie wywołany przed onCreate?
NodeDad

6
Tak, istnieje - domyślny konstruktor (ten bez parametrów). Ale ma bardzo ograniczone zastosowanie do bardzo podstawowych celów inicjalizacji. Zazwyczaj należy nie używać, chyba że naprawdę wiesz co robisz. I nawet wtedy powinieneś pomyśleć dwa razy, czy istnieje lepszy sposób robienia rzeczy.
Mjoellnir

1
Myślę, że ten link może pomóc w lepszym zrozumieniu cyklu życia działania. iphtechnologies.com/understanding-lifecycle-in-android-activity
Ashish Kumar Mishra

162

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

cykl życia aktywności

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

6
„Po otwarciu dowolnego okna dialogowego wywoływana jest funkcja onPause ()”, nie jest to prawdą dla alertu dialogowego. Jest wywoływany tylko wtedy, gdy samo okno dialogowe jest działaniem dialogowym (motyw ustawiony na @android: style / Theme.Dialog).
gaurav jain

2
Wartościowa odpowiedź. Prześlij to do Google, aby dodać do ich dokumentacji. Zapisuję twoją odpowiedź do dokumentu Worda, aby zachować!
likejudo

Nie rozumiem „Dowolny telefon dzwoni i użytkownik w aplikacji”. Jaki dokładnie jest scenariusz? Moim pierwszym było, jeśli użytkownik jest w aplikacji, a telefon zacznie dzwonić, to onPause () -> onStop () na wypadek, gdyby połączenie pełnoekranowe stało się połączeniem. W przypadku połączenia przychodzącego heads-up wiadomość może być po prostu OnResume -> onPause (), ale nie jestem tego pewien. Jaka jest sytuacja w wezwaniu do onPause -> onResume? Czy pod koniec rozmowy?
Sotti

Właśnie tego szukałem. Chciałem tylko wiedzieć, gdzie mam zadzwonić do interfejsu API.
Heisenberg

Podobała mi się twoja odpowiedź oparta na scenariuszu .
kokabi

155

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:

wprowadź opis zdjęcia tutaj


1
Zależy. O ile nie rozwiąże to zamieszania, długie imię nie zaszkodzi. Np .: onRoutePresentationDisplayChanged () jest w dużej mierze funkcją z wewnętrznego zestawu SDK Androida
Nilesh Pawar

12
Osobiście nie uważam, że twoje imiona są bardziej intuicyjne, a przy Fragmentach tak naprawdę nie koreluje.
Martin Marconcini,

9
Pozytywne. Bardziej pomocna niż oficjalna dokumentacja
bad_keypoints

3
To świetny post. Jeden problem. Gdy wpiszesz w Androidzie metody cyklu życia Andoid, ten obraz pojawi się nad opcją wyszukiwania (nawet w trybie wyszukiwania obrazu) jako odpowiedź na metody cyklu życia Androida. Nieświadomi (lub leniwi w zależności od tego, jak na to spojrzysz) mogą łatwo wprowadzić się w błąd, chyba że podążą za linkiem StackOverflow zamiast klikać obraz schematu blokowego (twój obraz).
Andrew S

1
Tak. Właśnie tego szukałem. Ktoś powinien napisać książkę (lub dokument?) Z takimi rzeczami. onResume itp. nie ma sensu.
Harsh Kanchina

22

CYKL ŻYCIA ANDROIDA

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


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ń


jakiś przykład dla onPause to onResume ?
zeeali

14

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:

Cykl życia aktywności Androida


8

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.


czy możemy nazwać metodę onPause jako etap pośredni między działaniem, które zaczyna tracić koncentrację i staje się w końcu niewidoczne dla użytkownika, a metodą Onstop, jak wtedy, gdy działanie stało się całkowicie niewidoczne dla użytkownika
Nav

Myślę, że tak powinno być.
Masiar

3
@Nav Załóżmy, że są 3 aktywności 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.
MKJParekh,

3

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

wprowadź opis zdjęcia tutaj

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.


0

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).

Korzystając z naszej strony potwierdzasz, że przeczytałeś(-aś) i rozumiesz nasze zasady używania plików cookie i zasady ochrony prywatności.
Licensed under cc by-sa 3.0 with attribution required.