Siklus hidup aktivitas Android - untuk apa semua metode ini?

Apa siklus hidup dari aktivitas Android? Mengapa begitu banyak metode terdengar sama ( onCreate(), onStart(), onResume()) disebut selama inisialisasi, dan banyak orang lain ( onPause(), onStop(), onDestroy()) disebut di akhir?

Kapan metode-metode ini disebut, dan bagaimana cara menggunakannya dengan benar?

Lihat di Siklus Hidup Aktivitas (di Pengembang Android).

onCreate () :

Disebut ketika aktivitas pertama kali dibuat. Di sinilah Anda harus melakukan semua pengaturan statis normal: buat tampilan, ikat data ke daftar, dll. Metode ini juga memberi Anda Bundel yang berisi keadaan beku aktivitas sebelumnya, jika ada. Selalu diikuti oleh onStart ().

onRestart () :

Dipanggil setelah aktivitas Anda dihentikan, sebelum mulai lagi. Selalu diikuti oleh onStart ()

onStart () :

Disebut ketika aktivitas menjadi terlihat oleh pengguna. Diikuti oleh onResume () jika aktivitas datang ke latar depan.

onResume () :

Disebut ketika aktivitas akan mulai berinteraksi dengan pengguna. Pada titik ini, aktivitas Anda berada di atas tumpukan aktivitas, dengan input pengguna menuju ke sana. Selalu diikuti oleh onPause ().

onPause () :

Disebut sebagai bagian dari siklus hidup aktivitas ketika suatu aktivitas berjalan ke latar belakang, tetapi belum (belum) terbunuh. Mitra untuk onResume (). Ketika aktivitas B diluncurkan di depan aktivitas A, panggilan balik ini akan dipanggil pada A. B tidak akan dibuat sampai A onPause () kembali, jadi pastikan untuk tidak melakukan apa pun yang panjang di sini.

onStop () :

Dipanggil saat Anda tidak lagi terlihat oleh pengguna. Anda selanjutnya akan menerima onRestart (), onDestroy (), atau tidak sama sekali, tergantung pada aktivitas pengguna selanjutnya. Perhatikan bahwa metode ini mungkin tidak pernah dipanggil, dalam situasi memori rendah di mana sistem tidak memiliki cukup memori untuk menjaga proses aktivitas Anda berjalan setelah metode onPause () dipanggil.

onDestroy () :

Panggilan terakhir yang Anda terima sebelum aktivitas Anda dihancurkan. Ini bisa terjadi karena aktivitas sedang menyelesaikan (seseorang bernama selesai () di atasnya, atau karena sistem sementara menghancurkan instance aktivitas ini untuk menghemat ruang. Anda dapat membedakan> dua skenario ini dengan metode isFinishing ().

Ketika Kegiatan pertama kali memuat acara disebut sebagai berikut:

onCreate()
onStart()
onResume()

Ketika Anda mengklik tombol Telepon , Kegiatan pergi ke latar belakang dan acara di bawah ini disebut:

onPause()
onStop()

Keluar dari dialer telepon dan acara di bawah ini akan dipanggil:

onRestart()
onStart()
onResume()

Ketika Anda mengklik tombol kembali ATAU mencoba untuk menyelesaikan () aktivitas acara disebut sebagai berikut:

onPause()
onStop()
onDestroy()

Negara Aktivitas

OS Android menggunakan antrian prioritas untuk membantu mengelola aktivitas yang berjalan di perangkat. Berdasarkan status aktivitas Android tertentu, ia akan diberi prioritas tertentu dalam OS. Sistem prioritas ini membantu Android mengidentifikasi kegiatan yang tidak lagi digunakan, memungkinkan OS untuk mendapatkan kembali memori dan sumber daya. Diagram berikut menggambarkan kondisi yang dapat dilalui suatu aktivitas, selama masa pakainya:

Negara-negara ini dapat dibagi menjadi tiga kelompok utama sebagai berikut:

Aktif atau Berlari - Aktivitas dianggap aktif atau berjalan jika berada di latar depan, juga dikenal sebagai bagian atas tumpukan aktivitas. Ini dianggap sebagai kegiatan prioritas tertinggi dalam tumpukan Aktivitas Android, dan karenanya hanya akan dibunuh oleh OS dalam situasi ekstrem, seperti jika aktivitas tersebut mencoba menggunakan lebih banyak memori daripada yang tersedia pada perangkat karena ini dapat menyebabkan UI menjadi tidak responsif.

Dijeda - Saat perangkat tertidur, atau suatu aktivitas masih terlihat tetapi sebagian disembunyikan oleh aktivitas baru, tidak berukuran penuh atau transparan, aktivitas tersebut dianggap dijeda. Aktivitas yang dijeda masih hidup, yaitu, mereka memelihara semua informasi negara dan anggota, dan tetap melekat pada window manager. Ini dianggap sebagai aktivitas prioritas tertinggi kedua di tumpukan Aktivitas Android dan, karenanya, hanya akan dimatikan oleh OS jika mematikan aktivitas ini akan memenuhi persyaratan sumber daya yang diperlukan untuk menjaga Aktivitas Aktif / Lari stabil dan responsif.

Berhenti - Kegiatan yang sepenuhnya dikaburkan oleh kegiatan lain dianggap berhenti atau di latar belakang. Aktivitas yang dihentikan masih mencoba untuk mempertahankan informasi negara dan anggota mereka selama mungkin, tetapi aktivitas yang dihentikan dianggap sebagai prioritas terendah dari tiga negara dan, dengan demikian, OS akan membunuh aktivitas di negara ini terlebih dahulu untuk memenuhi kebutuhan sumber daya. kegiatan prioritas yang lebih tinggi.

* Contoh aktivitas untuk memahami siklus hidup **

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

Aktivitas memiliki enam status

• Dibuat
• Mulai
• Dilanjutkan
• Dijeda
• Berhenti
• Hancur

Siklus hidup aktivitas memiliki tujuh metode

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

Situasi

• Saat membuka aplikasi

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

• Ketika tombol kembali ditekan dan keluar dari aplikasi

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

• Saat tombol home ditekan

  onPaused() --> onStop()

• Setelah menekan tombol home ketika membuka lagi aplikasi dari daftar tugas terbaru atau mengklik ikon

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

• Saat membuka aplikasi, aplikasi lain dari bilah notifikasi atau pengaturan terbuka

  onPaused() --> onStop()

• Tombol kembali ditekan dari aplikasi atau pengaturan lain yang kemudian digunakan dapat melihat aplikasi kami

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

• Ketika ada dialog yang terbuka di layar

  onPause()

• Setelah mengabaikan dialog atau tombol kembali dari dialog

  onResume()

• Telepon apa pun berdering dan pengguna di aplikasi

  onPause() --> onResume() 

• Ketika pengguna menekan tombol jawab telepon

  onPause()

• Setelah panggilan selesai

  onResume()

• Saat layar ponsel mati

  onPaused() --> onStop()

• Ketika layar dihidupkan kembali

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

Seluruh kebingungan disebabkan karena Google memilih nama yang tidak intuivatif alih-alih sebagai berikut:

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 Aktivitas dapat diartikan sebagai:

SIKLUS HIDUP ANDROID

Ada tujuh metode yang mengelola siklus hidup aplikasi Android:

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

Jawab untuk apa semua metode ini untuk:

Mari kita ambil skenario sederhana di mana mengetahui urutan metode ini disebut akan membantu kita memberikan kejelasan mengapa mereka digunakan.

• Misalkan Anda menggunakan aplikasi kalkulator. Tiga metode dipanggil secara berturut-turut untuk memulai aplikasi.

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

• Ketika saya menggunakan aplikasi kalkulator, tiba-tiba ada panggilan masuk. Aktivitas kalkulator pergi ke latar belakang dan aktivitas lain mengatakan. Berurusan dengan panggilan datang ke latar depan, dan sekarang dua metode disebut berturut-turut.

onPause() - - -> onStop()

• Sekarang katakanlah saya menyelesaikan percakapan di telepon, aktivitas kalkulator datang ke latar depan, sehingga tiga metode disebut berturut-turut.

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

• Akhirnya, katakan saya telah menyelesaikan semua tugas di aplikasi kalkulator, dan saya ingin keluar dari aplikasi. Selanjutnya dua metode disebut berturut-turut.

onStop() - - -> onDestroy()

Ada empat kondisi yang bisa dilakukan oleh suatu kegiatan:

• Mulai Negara
• Menjalankan Negara
• Status Jeda
• Negara berhenti

Mulai negara melibatkan:

Membuat proses Linux baru, mengalokasikan memori baru untuk objek UI baru, dan mengatur seluruh layar. Jadi sebagian besar pekerjaan terlibat di sini.

Menjalankan negara melibatkan:

Aktivitas (status) yang saat ini ada di layar. Keadaan ini saja menangani hal-hal seperti mengetik di layar, dan menyentuh & mengklik tombol.

Keadaan jeda melibatkan:

Ketika suatu kegiatan tidak di latar depan dan sebaliknya itu di latar belakang, maka aktivitas tersebut dikatakan dalam keadaan jeda.

Negara berhenti melibatkan:

Aktivitas yang dihentikan hanya dapat dibeli ke latar depan dengan memulai kembali dan juga dapat dihancurkan pada titik waktu tertentu.

Manajer aktivitas menangani semua status ini sedemikian rupa sehingga pengalaman dan kinerja pengguna selalu yang terbaik bahkan dalam skenario di mana aktivitas baru ditambahkan ke aktivitas yang ada

Saya suka pertanyaan ini dan jawabannya, tetapi sejauh ini tidak ada cakupan callback yang lebih jarang digunakan seperti onPostCreate () atau onPostResume () . Steve Pomeroy telah mencoba diagram termasuk ini dan bagaimana mereka berhubungan dengan siklus hidup Fragmen Android , di https://github.com/xxv/android-lifecycle . Saya merevisi diagram besar Steve untuk memasukkan hanya bagian Activity dan memformatnya untuk cetakan satu halaman berukuran huruf. Saya telah mempostingnya sebagai teks PDF di https://github.com/code-read/android-lifecycle/blob/master/AndroidActivityLifecycle1.pdf dan di bawah ini adalah gambarnya:

Dari halaman Android Developers,

onPause ():

Disebut ketika sistem akan memulai kembali aktivitas sebelumnya. Ini biasanya digunakan untuk melakukan perubahan yang belum disimpan ke data yang persisten, menghentikan animasi dan hal-hal lain yang mungkin menghabiskan CPU, dll. Implementasi metode ini harus sangat cepat karena aktivitas selanjutnya tidak akan dilanjutkan hingga metode ini kembali. Diikuti oleh onResume () jika aktivitas kembali ke depan, atau onStop () jika tidak terlihat oleh pengguna.

onStop ():

Disebut ketika aktivitas tidak lagi terlihat oleh pengguna, karena aktivitas lain telah dilanjutkan dan mencakup yang ini. Ini bisa terjadi baik karena aktivitas baru sedang dimulai, yang sudah ada dibawa di depan yang ini, atau yang ini sedang dihancurkan. Diikuti oleh onRestart () jika aktivitas ini kembali berinteraksi dengan pengguna, atau onDestroy () jika aktivitas ini akan hilang.

Sekarang anggaplah ada tiga Kegiatan dan Anda pergi dari A ke B, maka onPause dari A akan dipanggil sekarang dari B ke C, kemudian onPause dari B dan onStop dari A akan dipanggil.

Aktivitas yang dijeda mendapat Resume dan Berhenti akan Restart.

Saat Anda menelepon this.finish(), onPause-onStop-onDestroy akan dipanggil. Hal utama yang harus diingat adalah: Aktivitas yang dihentikan dihentikan dan aktivitas yang Dihentikan akan Hancur setiap kali Android membutuhkan memori untuk operasi lain.

Saya harap itu cukup jelas.

Menambahkan beberapa info lebih lanjut di atas jawaban berperingkat tinggi (Menambahkan bagian tambahan KILLABLE dan serangkaian metode berikutnya, yang akan dipanggil dalam siklus hidup):

Sumber: developer.android.com

Perhatikan kolom "Dapat Dibunuh " pada tabel di atas - untuk metode yang ditandai sebagai dapat dimatikan, setelah metode itu mengembalikan proses yang menjadi hosting, aktivitas tersebut dapat dimatikan oleh sistem kapan saja tanpa ada baris kode yang dieksekusi.

Karena itu, Anda harus menggunakan onPause()metode ini untuk menulis data persisten (seperti suntingan pengguna) ke penyimpanan. Selain itu, metode onSaveInstanceState(Bundle)ini dipanggil sebelum menempatkan aktivitas dalam keadaan latar belakang seperti itu, yang memungkinkan Anda untuk menyimpan keadaan instance dinamis apa pun dalam aktivitas Anda ke dalam yang diberikan Bundle, untuk kemudian diterima onCreate(Bundle)jika aktivitas perlu dibuat kembali.

Perhatikan bahwa penting untuk menyimpan data persisten onPause()alih-alih onSaveInstanceState(Bundle)karena yang terakhir bukan bagian dari daur ulang siklus hidup, jadi tidak akan dipanggil dalam setiap situasi seperti yang dijelaskan dalam dokumentasinya.

Saya ingin menambahkan beberapa metode lagi. Ini tidak terdaftar sebagai metode siklus hidup tetapi mereka akan dipanggil selama siklus hidup tergantung pada beberapa kondisi. Tergantung pada kebutuhan Anda, Anda mungkin harus menerapkan metode ini dalam aplikasi Anda untuk penanganan negara yang tepat.

onPostCreate(Bundle savedInstanceState)

Disebut ketika aktivitas start-up selesai (setelah onStart()dan onRestoreInstanceState(Bundle)telah dipanggil).

onPostResume()

Disebut ketika aktivitas melanjutkan selesai (setelah onResume()dipanggil).

onSaveInstanceState(Bundle outState)

Dipanggil untuk mengambil status per instance dari suatu aktivitas sebelum dibunuh sehingga status tersebut dapat dipulihkan dalam onCreate(Bundle)atau onRestoreInstanceState(Bundle)(Bundel yang dihuni oleh metode ini akan diteruskan ke keduanya).

onRestoreInstanceState(Bundle savedInstanceState)

Metode ini dipanggil setelah onStart()ketika aktivitas sedang diinisialisasi ulang dari keadaan yang sebelumnya disimpan, diberikan di sini di savedInstanceState.

Kode aplikasi saya menggunakan semua metode ini:

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

Aktivitas Masuk:

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

output: (Sebelum jeda)

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

output: (Setelah melanjutkan dari jeda)

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

Catatan yang onPostResume()dipanggil meskipun itu tidak dikutip sebagai metode siklus hidup.

Saya menjalankan beberapa log sesuai jawaban di atas dan di sini adalah output:

Mulai Kegiatan

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: 

Menghentikan Aktivitas

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: 

Menurut pendapat pribadi saya, hanya dua yang diperlukan onStart dan onStop.

onResume tampaknya ada di setiap instance untuk kembali, dan onPause dalam setiap instance meninggalkan (kecuali untuk menutup aplikasi).