Dialog adalah jendela kecil yang meminta pengguna untuk membuat keputusan atau memasukkan informasi tambahan. Dialog tidak mengisi layar dan biasanya digunakan untuk kejadian modal yang mengharuskan pengguna untuk melakukan aksi sebelum bisa melanjutkan.
Desain Dialog
Untuk informasi tentang cara mendesain dialog, termasuk saran untuk bahasa, bacalah panduan Desain dialog.

Kelas Dialog
adalah kelas basis untuk dialog, namun Anda
harus menghindari pembuatan instance Dialog
secara langsung.
Sebagai gantinya, gunakan salah satu subkelas berikut:
AlertDialog
- Dialog yang bisa menampilkan judul, hingga tiga tombol, daftar item yang dapat dipilih, atau layout khusus.
DatePickerDialog
atauTimePickerDialog
- Dialog berisi UI yang sudah didefinisikan dan memungkinkan pengguna memilih tanggal atau waktu.
Hindari ProgressDialog
Android menyertakan kelas dialog lain yang disebut
ProgressDialog
yang menampilkan dialog berisi progress-bar. Akan tetapi, jika Anda
perlu menunjukkan kemajuan pemuatan ataupun kemajuan yang tidak pasti, maka Anda harus mengikuti
panduan desain untuk Kemajuan &
Aktivitas dan menggunakan ProgressBar
dalam layout Anda.
Kelas-kelas ini mendefinisikan gaya dan struktur dialog Anda, namun Anda harus
menggunakan DialogFragment
sebagai kontainer dialog Anda.
Kelas DialogFragment
menyediakan semua kontrol yang Anda
perlukan untuk membuat dialog dan mengelola penampilannya, sebagai ganti memanggil metode
pada objek Dialog
.
Menggunakan DialogFragment
untuk mengelola dialog
akan memastikan bahwa kelas itu menangani kejadian daur hidup
dengan benar seperti ketika pengguna menekan tombol Kembali atau memutar layar. Kelas DialogFragment
juga memungkinkan Anda menggunakan ulang UI dialog sebagai
komponen yang bisa disematkan dalam UI yang lebih besar, persis seperti Fragment
biasa (seperti saat Anda ingin dialog UI muncul berbeda
pada layar besar dan kecil).
Bagian-bagian berikutnya dalam panduan ini akan menjelaskan cara menggunakan DialogFragment
yang dikombinasikan dengan objek AlertDialog
.
Jika Anda ingin membuat picker tanggal atau waktu, Anda harus membaca panduan
Picker.
Catatan:
Karena kelas DialogFragment
mulanya ditambahkan pada
Android 3.0 (API level 11), dokumen ini menjelaskan cara menggunakan kelas DialogFragment
yang disediakan bersama Pustaka Dukungan. Dengan menambahkan pustaka ini
ke aplikasi, Anda bisa menggunakan DialogFragment
dan berbagai
API lain pada perangkat yang menjalankan Android 1.6 atau yang lebih tinggi. Jika versi minimum yang didukung aplikasi Anda
adalah API level 11 atau yang lebih tinggi, maka Anda bisa menggunakan versi kerangka kerja DialogFragment
, namun ketahuilah bahwa tautan dalam dokumen ini adalah untuk API
pustaka dukungan. Saat menggunakan pustaka dukungan,
pastikan Anda mengimpor kelas android.support.v4.app.DialogFragment
dan bukan android.app.DialogFragment
.
Membuat Fragmen Dialog
Anda bisa menghasilkan beragam rancangan dialog—termasuk
layout khusus dan desain yang dijelaskan dalam panduan desain Dialog
—dengan memperluas
DialogFragment
dan membuat AlertDialog
dalam metode callback onCreateDialog()
.
Misalnya, berikut ini sebuah AlertDialog
dasar yang dikelola dalam
DialogFragment
:
public class FireMissilesDialogFragment extends DialogFragment { @Override public Dialog onCreateDialog(Bundle savedInstanceState) { // Use the Builder class for convenient dialog construction AlertDialog.Builder builder = new AlertDialog.Builder(getActivity()); builder.setMessage(R.string.dialog_fire_missiles) .setPositiveButton(R.string.fire, new DialogInterface.OnClickListener() { public void onClick(DialogInterface dialog, int id) { // FIRE ZE MISSILES! } }) .setNegativeButton(R.string.cancel, new DialogInterface.OnClickListener() { public void onClick(DialogInterface dialog, int id) { // User cancelled the dialog } }); // Create the AlertDialog object and return it return builder.create(); } }

Gambar 1. Dialog dengan satu pesan dan dua tombol aksi.
Sekarang, bila Anda membuat instance kelas ini dan memanggil show()
pada objek itu, dialog akan muncul seperti
yang ditampilkan dalam gambar 1.
Bagian berikutnya menjelaskan lebih jauh tentang penggunaan API AlertDialog.Builder
untuk membuat dialog.
Bergantung pada seberapa rumit dialog tersebut, Anda bisa menerapkan berbagai metode callback lain
dalam DialogFragment
, termasuk semua
metode daur hidup fragmen dasar.
Membangun Dialog Peringatan
Kelas AlertDialog
memungkinkan Anda membangun berbagai desain dialog dan
sering kali satu-satunya kelas dialog yang akan Anda perlukan.
Seperti yang ditampilkan dalam gambar 2, ada tiga region pada dialog peringatan:

Gambar 2. Layout dialog.
- Judul
Area ini opsional dan hanya boleh digunakan bila area materi ditempati oleh pesan terperinci, daftar, atau layout khusus. Jika Anda perlu menyatakan pesan atau pertanyaan sederhana (seperti dialog dalam gambar 1), Anda tidak memerlukan judul.
- Area materi
Area ini bisa menampilkan pesan, daftar, atau layout khusus lainnya.
- Tombol aksi
Tidak boleh ada lebih dari tiga tombol aksi dalam sebuah dialog.
Kelas AlertDialog.Builder
menyediakan API yang memungkinkan Anda membuat AlertDialog
dengan jenis materi ini, termasuk layout khusus.
Untuk membangun AlertDialog
:
// 1. Instantiate anAlertDialog.Builder
with its constructor AlertDialog.Builder builder = new AlertDialog.Builder(getActivity()); // 2. Chain together various setter methods to set the dialog characteristics builder.setMessage(R.string.dialog_message) .setTitle(R.string.dialog_title); // 3. Get theAlertDialog
fromcreate()
AlertDialog dialog = builder.create();
Topik-topik selanjutnya menampilkan cara mendefinisikan berbagai atribut dialog dengan menggunakan
kelas AlertDialog.Builder
.
Menambahkan tombol
Untuk menambahkan tombol aksi seperti dalam gambar 2,
panggil metode setPositiveButton()
dan
setNegativeButton()
:
AlertDialog.Builder builder = new AlertDialog.Builder(getActivity()); // Add the buttons builder.setPositiveButton(R.string.ok, new DialogInterface.OnClickListener() { public void onClick(DialogInterface dialog, int id) { // User clicked OK button } }); builder.setNegativeButton(R.string.cancel, new DialogInterface.OnClickListener() { public void onClick(DialogInterface dialog, int id) { // User cancelled the dialog } }); // Set other dialog properties ... // Create the AlertDialog AlertDialog dialog = builder.create();
Metode set...Button()
mengharuskan judul tombol (disediakan
oleh sumber daya string) dan
DialogInterface.OnClickListener
yang mendefinisikan aksi yang diambil
bila pengguna menekan tombol.
Ada tiga macam tombol aksi yang Anda bisa tambahkan:
- Positif
- Anda harus menggunakan tipe ini untuk menerima dan melanjutkan aksi (aksi "OK").
- Negatif
- Anda harus menggunakan tipe ini untuk membatalkan aksi.
- Netral
- Anda harus menggunakan tipe ini bila pengguna mungkin tidak ingin melanjutkan aksi, namun tidak ingin membatalkan. Tipe ini muncul antara tombol positif dan tombol negatif. Misalnya, aksi bisa berupa "Ingatkan saya nanti".
Anda hanya bisa menambahkan salah satu tipe tombol ke AlertDialog
. Artinya, Anda tidak bisa memiliki lebih dari satu tombol "positif".

Gambar 3. Dialog dengan satu judul dan daftar.
Menambahkan daftar
Ada tiga macam daftar yang tersedia pada API AlertDialog
:
- Daftar pilihan tunggal biasa
- Daftar pilihan tunggal persisten (tombol radio)
- Daftar pilihan ganda persisten (kotak centang)
Untuk membuat daftar pilihan tunggal seperti dalam gambar 3,
gunakan metode setItems()
:
@Override public Dialog onCreateDialog(Bundle savedInstanceState) { AlertDialog.Builder builder = new AlertDialog.Builder(getActivity()); builder.setTitle(R.string.pick_color) .setItems(R.array.colors_array, new DialogInterface.OnClickListener() { public void onClick(DialogInterface dialog, int which) { // The 'which' argument contains the index position // of the selected item } }); return builder.create(); }
Karena daftar muncul dalam area materi dialog,
dialog tidak bisa menampilkan pesan dan daftar sekaligus dan Anda harus menetapkan judul untuk
dialog dengan setTitle()
.
Untuk menetapkan item daftar, panggil setItems()
, dengan meneruskan sebuah larik.
Atau, Anda bisa menetapkan daftar menggunakan setAdapter()
. Hal ini memungkinkan Anda mendukung daftar
dengan data dinamis (seperti dari database) dengan menggunakan ListAdapter
.
Jika Anda memilih untuk mendukung daftar dengan ListAdapter
,
selalu gunakan sebuah Loader
agar materi dimuat
secara asinkron. Hal ini dijelaskan lebih jauh dalam panduan
Membangun Layout
dengan Adaptor dan Loader.
Catatan: Secara default, menyentuh sebuah item daftar akan menutup dialog, kecuali Anda menggunakan salah satu daftar pilihan persisten berikut ini.

Gambar 4. Daftar item pilihan ganda.
Menambahkan daftar pilihan ganda atau pilihan tunggal persisten
Untuk menambahkan daftar item pilihan ganda (kotak centang) atau
item pilihan tunggal (tombol radio), gunakan masing-masing metode
setMultiChoiceItems()
, atau
setSingleChoiceItems()
.
Misalnya, berikut ini cara membuat daftar pilihan ganda seperti
yang ditampilkan dalam gambar 4 yang menyimpan item
yang dipilih dalam ArrayList
:
@Override public Dialog onCreateDialog(Bundle savedInstanceState) { mSelectedItems = new ArrayList(); // Where we track the selected items AlertDialog.Builder builder = new AlertDialog.Builder(getActivity()); // Set the dialog title builder.setTitle(R.string.pick_toppings) // Specify the list array, the items to be selected by default (null for none), // and the listener through which to receive callbacks when items are selected .setMultiChoiceItems(R.array.toppings, null, new DialogInterface.OnMultiChoiceClickListener() { @Override public void onClick(DialogInterface dialog, int which, boolean isChecked) { if (isChecked) { // If the user checked the item, add it to the selected items mSelectedItems.add(which); } else if (mSelectedItems.contains(which)) { // Else, if the item is already in the array, remove it mSelectedItems.remove(Integer.valueOf(which)); } } }) // Set the action buttons .setPositiveButton(R.string.ok, new DialogInterface.OnClickListener() { @Override public void onClick(DialogInterface dialog, int id) { // User clicked OK, so save the mSelectedItems results somewhere // or return them to the component that opened the dialog ... } }) .setNegativeButton(R.string.cancel, new DialogInterface.OnClickListener() { @Override public void onClick(DialogInterface dialog, int id) { ... } }); return builder.create(); }
Walaupun daftar biasa maupun daftar dengan tombol radio
menyediakan aksi "pilihan tunggal", Anda harus menggunakan setSingleChoiceItems()
jika ingin mempertahankan pilihan pengguna.
Yakni, jika nanti membuka dialog lagi untuk menunjukkan pilihan pengguna,
maka Anda perlu membuat daftar dengan tombol radio.
Membuat Layout Khusus

Gambar 5. Layout dialog khusus.
Jika Anda menginginkan layout khusus dalam dialog, buatlah layout dan tambahkan ke
AlertDialog
dengan memanggil setView()
pada objek AlertDialog.Builder
Anda.
Secara default, layout khusus akan mengisi jendela dialog, namun Anda masih bisa
menggunakan metode AlertDialog.Builder
untuk menambahkan tombol dan judul.
Misalnya, berikut ini adalah file layout untuk dialog dalam Gambar 5:
res/layout/dialog_signin.xml
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" android:orientation="vertical" android:layout_width="wrap_content" android:layout_height="wrap_content"> <ImageView android:src="@drawable/header_logo" android:layout_width="match_parent" android:layout_height="64dp" android:scaleType="center" android:background="#FFFFBB33" android:contentDescription="@string/app_name" /> <EditText android:id="@+id/username" android:inputType="textEmailAddress" android:layout_width="match_parent" android:layout_height="wrap_content" android:layout_marginTop="16dp" android:layout_marginLeft="4dp" android:layout_marginRight="4dp" android:layout_marginBottom="4dp" android:hint="@string/username" /> <EditText android:id="@+id/password" android:inputType="textPassword" android:layout_width="match_parent" android:layout_height="wrap_content" android:layout_marginTop="4dp" android:layout_marginLeft="4dp" android:layout_marginRight="4dp" android:layout_marginBottom="16dp" android:fontFamily="sans-serif" android:hint="@string/password"/> </LinearLayout>
Tip: Secara default, bila Anda telah menyetel sebuah elemen EditText
agar menggunakan tipe masukan "textPassword"
, jenis font akan disetel ke spasi tunggal, sehingga
Anda harus mengubah jenis font ke "sans-serif"
agar kedua bidang teks menggunakan
gaya font yang cocok.
Untuk memekarkan layout dalam DialogFragment
Anda,
ambillah LayoutInflater
dengan
getLayoutInflater()
dan panggil
inflate()
, dengan parameter pertama
adalah ID sumber daya layout dan parameter kedua adalah tampilan induk untuk layout.
Selanjutnya Anda bisa memanggil setView()
untuk menempatkan layout dalam dialog.
@Override public Dialog onCreateDialog(Bundle savedInstanceState) { AlertDialog.Builder builder = new AlertDialog.Builder(getActivity()); // Get the layout inflater LayoutInflater inflater = getActivity().getLayoutInflater(); // Inflate and set the layout for the dialog // Pass null as the parent view because its going in the dialog layout builder.setView(inflater.inflate(R.layout.dialog_signin, null)) // Add action buttons .setPositiveButton(R.string.signin, new DialogInterface.OnClickListener() { @Override public void onClick(DialogInterface dialog, int id) { // sign in the user ... } }) .setNegativeButton(R.string.cancel, new DialogInterface.OnClickListener() { public void onClick(DialogInterface dialog, int id) { LoginDialogFragment.this.getDialog().cancel(); } }); return builder.create(); }
Tip: Jika Anda menginginkan dialog khusus,
Anda bisa menampilkan Activity
sebagai dialog
daripada menggunakan API Dialog
. Cukup buat satu aktivitas dan setel temanya ke
Theme.Holo.Dialog
di elemen manifes <activity>
:
<activity android:theme="@android:style/Theme.Holo.Dialog" >
Demikian saja. Aktivitas sekarang ditampilkan dalam jendela dialog, sebagai ganti layar penuh.
Meneruskan Kejadian Kembali ke Host Dialog
Bila pengguna menyentuh salah satu tombol aksi dialog atau memilih satu item dari daftarnya,
DialogFragment
Anda bisa melakukan sendiri aksi yang diperlukan
, namun sering kali Anda perlu mengirim kejadian itu ke aktivitas atau fragmen yang
membuka dialog. Caranya, definisikan antarmuka dengan sebuah metode untuk masing-masing tipe kejadian klik.
Lalu implementasikan antarmuka itu dalam komponen host yang akan
menerima kejadian aksi dari dialog.
Misalnya, berikut ini adalah DialogFragment
yang mendefinisikan
antarmuka yang akan digunakan untuk mengirim kembali suatu kejadian ke aktivitas host:
public class NoticeDialogFragment extends DialogFragment { /* The activity that creates an instance of this dialog fragment must * implement this interface in order to receive event callbacks. * Each method passes the DialogFragment in case the host needs to query it. */ public interface NoticeDialogListener { public void onDialogPositiveClick(DialogFragment dialog); public void onDialogNegativeClick(DialogFragment dialog); } // Use this instance of the interface to deliver action events NoticeDialogListener mListener; // Override the Fragment.onAttach() method to instantiate the NoticeDialogListener @Override public void onAttach(Activity activity) { super.onAttach(activity); // Verify that the host activity implements the callback interface try { // Instantiate the NoticeDialogListener so we can send events to the host mListener = (NoticeDialogListener) activity; } catch (ClassCastException e) { // The activity doesn't implement the interface, throw exception throw new ClassCastException(activity.toString() + " must implement NoticeDialogListener"); } } ... }
Aktivitas yang menjadi host dialog tersebut akan membuat instance dialog
dengan konstruktor fragmen dialog dan menerima kejadian dialog
melalui implementasi antarmuka NoticeDialogListener
:
public class MainActivity extends FragmentActivity implements NoticeDialogFragment.NoticeDialogListener{ ... public void showNoticeDialog() { // Create an instance of the dialog fragment and show it DialogFragment dialog = new NoticeDialogFragment(); dialog.show(getSupportFragmentManager(), "NoticeDialogFragment"); } // The dialog fragment receives a reference to this Activity through the // Fragment.onAttach() callback, which it uses to call the following methods // defined by the NoticeDialogFragment.NoticeDialogListener interface @Override public void onDialogPositiveClick(DialogFragment dialog) { // User touched the dialog's positive button ... } @Override public void onDialogNegativeClick(DialogFragment dialog) { // User touched the dialog's negative button ... } }
Karena aktivitas host mengimplementasikan NoticeDialogListener
—yang
diberlakukan oleh metode callback onAttach()
di atas,—fragmen dialog bisa menggunakan
metode callback antarmuka untuk mengirimkan kejadian klik ke aktivitas:
public class NoticeDialogFragment extends DialogFragment { ... @Override public Dialog onCreateDialog(Bundle savedInstanceState) { // Build the dialog and set up the button click handlers AlertDialog.Builder builder = new AlertDialog.Builder(getActivity()); builder.setMessage(R.string.dialog_fire_missiles) .setPositiveButton(R.string.fire, new DialogInterface.OnClickListener() { public void onClick(DialogInterface dialog, int id) { // Send the positive button event back to the host activity mListener.onDialogPositiveClick(NoticeDialogFragment.this); } }) .setNegativeButton(R.string.cancel, new DialogInterface.OnClickListener() { public void onClick(DialogInterface dialog, int id) { // Send the negative button event back to the host activity mListener.onDialogNegativeClick(NoticeDialogFragment.this); } }); return builder.create(); } }
Menampilkan Dialog
Bila Anda ingin menampilkan dialog, buatlah instance DialogFragment
dan panggil show()
, dengan meneruskan FragmentManager
dan nama tag
untuk fragmen dialognya.
Anda bisa mendapatkan FragmentManager
dengan memanggil
getSupportFragmentManager()
dari
FragmentActivity
atau getFragmentManager()
dari Fragment
. Misalnya:
public void confirmFireMissiles() { DialogFragment newFragment = new FireMissilesDialogFragment(); newFragment.show(getSupportFragmentManager(), "missiles"); }
Argumen kedua, "missiles"
, adalah nama tag unik yang digunakan sistem untuk menyimpan
dan memulihkan status fragmen bila diperlukan. Tag ini juga memungkinkan Anda mendapatkan tuas ke
fragmen dengan memanggil findFragmentByTag()
.
Menampilkan Dialog sebagai Layar Penuh atau Fragmen Tersemat
Anda mungkin memiliki desain UI yang di dalamnya Anda ingin UI muncul sebagai dialog dalam beberapa
situasi, namun sebagai layar penuh atau fragmen tersemat dalam situasi lain (mungkin bergantung pada apakah
perangkat memiliki layar besar atau layar kecil). Kelas DialogFragment
menawarkan fleksibilitas ini karena masih bisa berperilaku sebagai Fragment
yang bisa disematkan.
Akan tetapi, dalam hal ini Anda tidak bisa menggunakan AlertDialog.Builder
atau objek Dialog
lain untuk membangun dialog. Jika
Anda ingin DialogFragment
bisa disematkan, Anda harus mendefinisikan UI dialog dalam layout, kemudian muat layout itu dalam metode callback
onCreateView()
.
Berikut ini adalah contoh DialogFragment
yang bisa muncul sebagai
dialog maupun fragmen yang bisa disematkan (menggunakan layout bernama purchase_items.xml
):
public class CustomDialogFragment extends DialogFragment { /** The system calls this to get the DialogFragment's layout, regardless of whether it's being displayed as a dialog or an embedded fragment. */ @Override public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) { // Inflate the layout to use as dialog or embedded fragment return inflater.inflate(R.layout.purchase_items, container, false); } /** The system calls this only when creating the layout in a dialog. */ @Override public Dialog onCreateDialog(Bundle savedInstanceState) { // The only reason you might override this method when using onCreateView() is // to modify any dialog characteristics. For example, the dialog includes a // title by default, but your custom layout might not need it. So here you can // remove the dialog title, but you must call the superclass to get the Dialog. Dialog dialog = super.onCreateDialog(savedInstanceState); dialog.requestWindowFeature(Window.FEATURE_NO_TITLE); return dialog; } }
Dan berikut ini adalah beberapa kode yang memutuskan apakah akan menampilkan fragmen sebagai dialog atau UI layar penuh, berdasarkan ukuran layar:
public void showDialog() { FragmentManager fragmentManager = getSupportFragmentManager(); CustomDialogFragment newFragment = new CustomDialogFragment(); if (mIsLargeLayout) { // The device is using a large layout, so show the fragment as a dialog newFragment.show(fragmentManager, "dialog"); } else { // The device is smaller, so show the fragment fullscreen FragmentTransaction transaction = fragmentManager.beginTransaction(); // For a little polish, specify a transition animation transaction.setTransition(FragmentTransaction.TRANSIT_FRAGMENT_OPEN); // To make it fullscreen, use the 'content' root view as the container // for the fragment, which is always the root view for the activity transaction.add(android.R.id.content, newFragment) .addToBackStack(null).commit(); } }
Untuk informasi selengkapnya tentang melakukan transaksi fragmen, lihat panduan Fragmen.
Dalam contoh ini, nilai boolean mIsLargeLayout
menentukan apakah perangkat saat ini
harus menggunakan desain layout besar aplikasi (dan dengan demikian menampilkan fragmen ini sebagai dialog, bukan
layar penuh). Cara terbaik untuk mengatur jenis boolean ini adalah mendeklarasikan
nilai sumber daya boolean
dengan nilai sumber daya alternatif untuk berbagai ukuran layar. Misalnya, berikut ini adalah dua
versi sumber daya boolean untuk berbagai ukuran layar:
res/values/bools.xml
<!-- Default boolean values --> <resources> <bool name="large_layout">false</bool> </resources>
res/values-large/bools.xml
<!-- Large screen boolean values --> <resources> <bool name="large_layout">true</bool> </resources>
Selanjutnya Anda bisa melakukan inisialiasi nilai mIsLargeLayout
selama metode
onCreate()
aktivitas:
boolean mIsLargeLayout; @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); mIsLargeLayout = getResources().getBoolean(R.bool.large_layout); }
Menampilkan aktivitas sebagai dialog pada layar besar
Sebagai ganti menampilkan dialog berupa UI layar penuh saat di layar kecil, Anda bisa memperoleh
hasil yang sama dengan menampilkan Activity
sebagai dialog saat di
layar besar. Pendekatan yang Anda pilih bergantung pada desain aplikasi, namun
menampilkan aktivitas sebagai dialog sering kali berguna bila aplikasi Anda sudah didesain untuk
layar kecil dan Anda ingin meningkatkan pengalaman pada tablet dengan menampilkan aktivitas berjangka pendek
sebagai dialog.
Untuk menampilkan aktivitas sebagai dialog hanya saat di layar besar,
terapkan tema Theme.Holo.DialogWhenLarge
pada elemen manifes <activity>
:
<activity android:theme="@android:style/Theme.Holo.DialogWhenLarge" >
Untuk informasi selengkapnya tentang menata gaya aktivitas Anda dengan tema, lihat panduan Gaya dan Tema.
Menutup Dialog
Bila pengguna menyentuh salah satu tombol aksi yang dibuat dengan
AlertDialog.Builder
, sistem akan menutup dialog untuk Anda.
Sistem juga menutup dialog bila pengguna menyentuh sebuah item dalam daftar dialog, kecuali
bila daftar itu menggunakan tombol radio atau kotak centang. Jika tidak, Anda bisa menutup dialog secara manual
dengan memanggil dismiss()
pada DialogFragment
Anda.
Jika Anda perlu melakukan
tindakan tertentu saat dialog menghilang, Anda bisa mengimplementasikan metode onDismiss()
dalam DialogFragment
Anda.
Anda juga bisa membatalkan dialog. Ini merupakan kejadian khusus yang menunjukkan bahwa pengguna
secara eksplisit meninggalkan dialog tanpa menyelesaikan tugas. Hal ini terjadi jika pengguna menekan tombol
Kembali, menyentuh layar di luar area dialog,
atau jika Anda secara eksplisit memanggil cancel()
pada Dialog
(seperti saat merespons tombol "Cancel" dalam dialog).
Seperti yang ditampilkan dalam contoh di atas, Anda bisa merespons kejadian batal dengan mengimplementasikan
onCancel()
dalam kelas DialogFragment
Anda.
Catatan: Sistem akan memanggil
onDismiss()
pada tiap kejadian yang
memanggil callback onCancel()
. Akan tetapi,
jika Anda memanggil Dialog.dismiss()
atau DialogFragment.dismiss()
,
sistem akan memanggil onDismiss()
namun
bukan onCancel()
. Jadi biasanya Anda harus
memanggil dismiss()
bila pengguna menekan tombol
positif dalam dialog untuk membuang tampilan dialog.