Dialog

Mencoba cara Compose

Jetpack Compose adalah toolkit UI yang direkomendasikan untuk Android. Pelajari cara menambahkan komponen di Compose.

AlertDialog →

Dialog adalah jendela kecil yang meminta pengguna untuk keputusan atau memasukkan informasi tambahan. Dialog tidak memenuhi layar dan biasanya digunakan untuk peristiwa modal yang mengharuskan pengguna untuk melakukan tindakan sebelum mereka dapat melanjutkan.

Dialog adalah class dasar untuk dialog, tetapi jangan membuat instance Dialog secara langsung. Sebagai gantinya, gunakan salah satu dari subclass berikut:

AlertDialog

Dialog yang dapat menampilkan judul, hingga tiga tombol, daftar item yang dapat dipilih item, atau tata letak kustom.

DatePickerDialog atau TimePickerDialog

Dialog dengan UI yang telah ditetapkan memungkinkan pengguna memilih tanggal atau baik.

Semua class ini menentukan gaya dan struktur dialog Anda. Anda juga memerlukan suatu DialogFragment sebagai container untuk dialog Anda. Class DialogFragment menyediakan semua kontrol yang Anda perlukan untuk membuat dialog dan mengelola tampilannya, bukan memanggil metode pada objek Dialog.

Menggunakan DialogFragment untuk mengelola dialog akan membuatnya dengan benar menangani peristiwa siklus proses seperti saat pengguna mengetuk tombol Kembali atau memutar layar. Class DialogFragment juga memungkinkan Anda menggunakan kembali UI dialog sebagai komponen yang dapat disematkan dalam UI yang lebih besar—seperti tradisional Fragment—seperti seperti saat Anda ingin UI dialog tampak berbeda pada ukuran layar.

Bagian berikut dalam dokumen ini menjelaskan cara menggunakan DialogFragment dikombinasikan dengan AlertDialog . Jika Anda ingin membuat pemilih tanggal atau waktu, baca Tambahkan pemilih ke aplikasi.

Membuat fragmen dialog

Anda bisa membuat berbagai macam desain dialog—termasuk desain kustom tata letak dan yang dijelaskan dalam Desain Material Dialog—dengan memperluas DialogFragment dan membuat AlertDialog di onCreateDialog() .

Misalnya, berikut adalah AlertDialog dasar yang dikelola dalam DialogFragment:

class StartGameDialogFragment : DialogFragment() {
    override fun onCreateDialog(savedInstanceState: Bundle?): Dialog {
        return activity?.let {
            // Use the Builder class for convenient dialog construction.
            val builder = AlertDialog.Builder(it)
            builder.setMessage("Start game")
                .setPositiveButton("Start") { dialog, id ->
                    // START THE GAME!
                }
                .setNegativeButton("Cancel") { dialog, id ->
                    // User cancelled the dialog.
                }
            // Create the AlertDialog object and return it.
            builder.create()
        } ?: throw IllegalStateException("Activity cannot be null")
    }
}

class OldXmlActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_old_xml)

        StartGameDialogFragment().show(supportFragmentManager, "GAME_DIALOG")
    }
}

public class StartGameDialogFragment 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_start_game)
               .setPositiveButton(R.string.start, new DialogInterface.OnClickListener() {
                   public void onClick(DialogInterface dialog, int id) {
                       // START THE GAME!
                   }
               })
               .setNegativeButton(R.string.cancel, new DialogInterface.OnClickListener() {
                   public void onClick(DialogInterface dialog, int id) {
                       // User cancels the dialog.
                   }
               });
        // Create the AlertDialog object and return it.
        return builder.create();
    }
}
// ...

StartGameDialogFragment().show(supportFragmentManager, "GAME_DIALOG");

Saat Anda membuat instance class ini dan memanggil show() pada objek itu, dialog akan muncul seperti yang ditampilkan dalam gambar berikut.

Bagian berikutnya memberikan detail lebih lanjut tentang cara menggunakan AlertDialog.Builder API untuk membuat dialog.

Tergantung pada seberapa rumit dialognya, Anda dapat menerapkan berbagai metode callback lain di DialogFragment, termasuk semua metode metode siklus proses fragmen dasar.

Membuat dialog pemberitahuan

Class AlertDialog memungkinkan Anda membuat berbagai dialog desain dan sering kali satu-satunya kelas dialog yang Anda butuhkan. Seperti yang ditunjukkan di bawah ini ada tiga area dialog peringatan:

• Judul: ini opsional dan hanya digunakan jika area konten yang ditempati oleh pesan terperinci, daftar, atau tata letak khusus. Jika Anda ingin menyatakan pesan atau pertanyaan sederhana, Anda tidak memerlukan judul.
• Area konten: Area ini dapat menampilkan pesan, daftar, atau setelan kustom tata letak.
• Tombol tindakan: terdapat hingga tiga tombol tindakan dalam dialog.

Class AlertDialog.Builder menyediakan API yang memungkinkan Anda membuat AlertDialog dengan jenis konten ini, termasuk kustom tata letak.

Untuk membuat AlertDialog, lakukan langkah-langkah berikut:

val builder: AlertDialog.Builder = AlertDialog.Builder(context)
builder
    .setMessage("I am the message")
    .setTitle("I am the title")

val dialog: AlertDialog = builder.create()
dialog.show()

// 1. Instantiate an AlertDialog.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 the AlertDialog.
AlertDialog dialog = builder.create();

Cuplikan kode sebelumnya menghasilkan dialog ini:

Menambahkan tombol

Untuk menambahkan tombol tindakan seperti dalam gambar 2, panggil metode setPositiveButton() dan setNegativeButton() metode:

val builder: AlertDialog.Builder = AlertDialog.Builder(context)
builder
    .setMessage("I am the message")
    .setTitle("I am the title")
    .setPositiveButton("Positive") { dialog, which ->
        // Do something.
    }
    .setNegativeButton("Negative") { dialog, which ->
        // Do something else.
    }

val dialog: AlertDialog = builder.create()
dialog.show()

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 taps OK button.
           }
       });
builder.setNegativeButton(R.string.cancel, new DialogInterface.OnClickListener() {
           public void onClick(DialogInterface dialog, int id) {
               // User cancels the dialog.
           }
       });
// Set other dialog properties.
...

// Create the AlertDialog.
AlertDialog dialog = builder.create();

Metode set...Button() memerlukan judul untuk tombol — disediakan oleh resource string—dan suatu DialogInterface.OnClickListener yang mendefinisikan tindakan yang harus diambil ketika pengguna mengetuk tombol.

Ada tiga tombol tindakan yang dapat Anda tambahkan:

• Positif: gunakan ini untuk menerima dan melanjutkan tindakan ( "Oke" tertentu).
• Negatif: gunakan ini untuk membatalkan tindakan.
• Netral: gunakan ini ketika pengguna mungkin tidak ingin melanjutkan tindakan, tetapi tidak ingin membatalkannya. Kolom ini muncul di antara tombol positif dan tombol negatif. Misalnya, tindakan dapat berupa "Ingatkan saya nanti".

Anda hanya bisa menambahkan satu dari setiap tipe tombol ke AlertDialog. Sebagai contoh, Anda tidak boleh memiliki lebih dari satu "positif" tombol.

Cuplikan kode sebelumnya memberi Anda dialog pemberitahuan seperti berikut:

Menambahkan daftar

Ada tiga jenis daftar yang tersedia di AlertDialog API:

• Daftar pilihan tunggal konvensional.
• Daftar pilihan tunggal persisten (tombol pilihan).
• Daftar pilihan ganda persisten (kotak centang).

Untuk membuat daftar pilihan tunggal seperti dalam gambar 5, gunakan setItems() berikut:

val builder: AlertDialog.Builder = AlertDialog.Builder(context)
builder
    .setTitle("I am the title")
    .setPositiveButton("Positive") { dialog, which ->
        // Do something.
    }
    .setNegativeButton("Negative") { dialog, which ->
        // Do something else.
    }
    .setItems(arrayOf("Item One", "Item Two", "Item Three")) { dialog, which ->
        // Do something on item tapped.
    }

val dialog: AlertDialog = builder.create()
dialog.show()

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

Cuplikan kode ini menghasilkan dialog seperti berikut:

Dialog tidak dapat ditampilkan karena daftar muncul di area konten dialog pesan maupun daftar. Tetapkan judul untuk dialog dengan setTitle(). Untuk menentukan item untuk daftar, panggil setItems(), dengan meneruskan . Atau, Anda dapat menentukan daftar menggunakan setAdapter(). Hal ini memungkinkan Anda mencadangkan daftar dengan data dinamis—seperti dari menggunakan database ListAdapter.

Jika Anda mencadangkan daftar dengan ListAdapter, selalu gunakan Loader agar konten dimuat secara asinkron. Hal ini dijelaskan lebih lanjut dalam Membangun tata letak dengan adaptor dan Loader.

Menambahkan daftar pilihan ganda atau pilihan tunggal persisten

Untuk menambahkan daftar item pilihan ganda (kotak centang) atau item pilihan tunggal (tombol pilihan), gunakan setMultiChoiceItems() atau setSingleChoiceItems() masing-masing.

Misalnya, berikut cara membuat daftar pilihan ganda seperti yang ditunjukkan pada gambar 6 yang menyimpan item yang dipilih dalam ArrayList:

val builder: AlertDialog.Builder = AlertDialog.Builder(context)
builder
    .setTitle("I am the title")
    .setPositiveButton("Positive") { dialog, which ->
        // Do something.
    }
    .setNegativeButton("Negative") { dialog, which ->
        // Do something else.
    }
    .setMultiChoiceItems(
        arrayOf("Item One", "Item Two", "Item Three"), null) { dialog, which, isChecked ->
        // Do something.
    }

val dialog: AlertDialog = builder.create()
dialog.show()

@Override
public Dialog onCreateDialog(Bundle savedInstanceState) {
    selectedItems = 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 checks the item, add it to the selected
                       // items.
                       selectedItems.add(which);
                   } else if (selectedItems.contains(which)) {
                       // If the item is already in the array, remove it.
                       selectedItems.remove(which);
                   }
               }
           })
    // Set the action buttons
           .setPositiveButton(R.string.ok, new DialogInterface.OnClickListener() {
               @Override
               public void onClick(DialogInterface dialog, int id) {
                   // User taps OK, so save the selectedItems results
                   // somewhere or return them to the component that opens the
                   // dialog.
                   ...
               }
           })
           .setNegativeButton(R.string.cancel, new DialogInterface.OnClickListener() {
               @Override
               public void onClick(DialogInterface dialog, int id) {
                   ...
               }
           });

    return builder.create();
}

Dialog pemberitahuan pilihan tunggal bisa diperoleh seperti ini:

val builder: AlertDialog.Builder = AlertDialog.Builder(context)
builder
    .setTitle("I am the title")
    .setPositiveButton("Positive") { dialog, which ->
        // Do something.
    }
    .setNegativeButton("Negative") { dialog, which ->
        // Do something else.
    }
    .setSingleChoiceItems(
        arrayOf("Item One", "Item Two", "Item Three"), 0
    ) { dialog, which ->
        // Do something.
    }

val dialog: AlertDialog = builder.create()
dialog.show()

        String[] choices = {"Item One", "Item Two", "Item Three"};
        
        AlertDialog.Builder builder = AlertDialog.Builder(context);
        builder
                .setTitle("I am the title")
                .setPositiveButton("Positive", (dialog, which) -> {

                })
                .setNegativeButton("Negative", (dialog, which) -> {

                })
                .setSingleChoiceItems(choices, 0, (dialog, which) -> {

                });

        AlertDialog dialog = builder.create();
        dialog.show();

Ini menghasilkan contoh berikut:

Membuat tata letak kustom

Jika Anda menginginkan tata letak khusus dalam dialog, buat tata letak dan tambahkan ke AlertDialog dengan memanggil setView() pada objek AlertDialog.Builder.

Secara default, tata letak kustom akan mengisi jendela dialog, tetapi Anda masih bisa menggunakan Metode AlertDialog.Builder untuk menambahkan tombol dan judul.

Misalnya, berikut adalah file tata letak untuk dialog kustom sebelumnya tata letak:

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>

Untuk meng-inflate tata letak di DialogFragment, dapatkan LayoutInflater dengan getLayoutInflater() dan panggil inflate(). Parameter pertama adalah ID resource tata letak, dan parameter kedua adalah tampilan induk untuk tata letak. Anda kemudian dapat memanggil setView() untuk menempatkan tata letak dalam dialog. Hal ini ditunjukkan dalam contoh berikut.

override fun onCreateDialog(savedInstanceState: Bundle?): Dialog {
    return activity?.let {
        val builder = AlertDialog.Builder(it)
        // Get the layout inflater.
        val inflater = requireActivity().layoutInflater;

        // Inflate and set the layout for the dialog.
        // Pass null as the parent view because it's going in the dialog
        // layout.
        builder.setView(inflater.inflate(R.layout.dialog_signin, null))
                // Add action buttons.
                .setPositiveButton(R.string.signin,
                        DialogInterface.OnClickListener { dialog, id ->
                            // Sign in the user.
                        })
                .setNegativeButton(R.string.cancel,
                        DialogInterface.OnClickListener { dialog, id ->
                            getDialog().cancel()
                        })
        builder.create()
    } ?: throw IllegalStateException("Activity cannot be null")
}

@Override
public Dialog onCreateDialog(Bundle savedInstanceState) {
    AlertDialog.Builder builder = new AlertDialog.Builder(getActivity());
    // Get the layout inflater.
    LayoutInflater inflater = requireActivity().getLayoutInflater();

    // Inflate and set the layout for the dialog.
    // Pass null as the parent view because it's 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();
}

Jika Anda menginginkan dialog khusus, Anda bisa saja menampilkan Activity sebagai dialog alih-alih menggunakan Dialog API. Membuat aktivitas dan mengatur temanya menjadi Theme.Holo.Dialog di <activity> manifes:

<activity android:theme="@android:style/Theme.Holo.Dialog" >

Aktivitas sekarang ditampilkan dalam jendela dialog, bukan layar penuh.

Meneruskan peristiwa kembali ke host dialog

Saat pengguna mengetuk salah satu tombol tindakan dialog atau memilih item dari daftarnya, DialogFragment mungkin melakukan tindakan yang diperlukan tindakan itu sendiri, tetapi sering kali Anda ingin menyampaikan peristiwa tersebut ke aktivitas atau yang membuka dialog. Untuk melakukan ini, tentukan antarmuka dengan metode untuk setiap jenis peristiwa klik. Kemudian, implementasikan antarmuka tersebut di {i>host<i} yang menerima kejadian tindakan dari dialog.

Misalnya, berikut adalah DialogFragment yang menentukan antarmuka yang akan digunakan untuk mengirim peristiwa kembali ke aktivitas host:

class NoticeDialogFragment : DialogFragment() {
    // Use this instance of the interface to deliver action events.
    internal lateinit var listener: NoticeDialogListener

    // The activity that creates an instance of this dialog fragment must
    // implement this interface to receive event callbacks. Each method passes
    // the DialogFragment in case the host needs to query it.
    interface NoticeDialogListener {
        fun onDialogPositiveClick(dialog: DialogFragment)
        fun onDialogNegativeClick(dialog: DialogFragment)
    }

    // Override the Fragment.onAttach() method to instantiate the
    // NoticeDialogListener.
    override fun onAttach(context: Context) {
        super.onAttach(context)
        // Verify that the host activity implements the callback interface.
        try {
            // Instantiate the NoticeDialogListener so you can send events to
            // the host.
            listener = context as NoticeDialogListener
        } catch (e: ClassCastException) {
            // The activity doesn't implement the interface. Throw exception.
            throw ClassCastException((context.toString() +
                    " must implement NoticeDialogListener"))
        }
    }
}

public class NoticeDialogFragment extends DialogFragment {

    // The activity that creates an instance of this dialog fragment must
    // implement this interface 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 listener;

    // Override the Fragment.onAttach() method to instantiate the
    // NoticeDialogListener.
    @Override
    public void onAttach(Context context) {
        super.onAttach(context);
        // Verify that the host activity implements the callback interface.
        try {
            // Instantiate the NoticeDialogListener so you can send events to
            // the host.
            listener = (NoticeDialogListener) context;
        } catch (ClassCastException e) {
            // The activity doesn't implement the interface. Throw exception.
            throw new ClassCastException(activity.toString()
                    + " must implement NoticeDialogListener");
        }
    }
    ...
}

Aktivitas yang menghosting dialog akan membuat instance dialog dengan konstruktor fragmen dialog dan menerima peristiwa dialog melalui implementasi antarmuka NoticeDialogListener:

class MainActivity : FragmentActivity(),
        NoticeDialogFragment.NoticeDialogListener {

    fun showNoticeDialog() {
        // Create an instance of the dialog fragment and show it.
        val dialog = NoticeDialogFragment()
        dialog.show(supportFragmentManager, "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 fun onDialogPositiveClick(dialog: DialogFragment) {
        // User taps the dialog's positive button.
    }

    override fun onDialogNegativeClick(dialog: DialogFragment) {
        // User taps the dialog's negative button.
    }
}

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 taps the dialog's positive button.
        ...
    }

    @Override
    public void onDialogNegativeClick(DialogFragment dialog) {
        // User taps the dialog's negative button.
        ...
    }
}

Karena aktivitas host mengimplementasikan NoticeDialogListener—yang diberlakukan oleh onAttach() yang ditampilkan dalam contoh sebelumnya—fragmen dialog dapat gunakan metode callback antarmuka untuk mengirimkan peristiwa klik ke aktivitas:

    override fun onCreateDialog(savedInstanceState: Bundle): Dialog {
        return activity?.let {
            // Build the dialog and set up the button click handlers.
            val builder = AlertDialog.Builder(it)

            builder.setMessage(R.string.dialog_start_game)
                    .setPositiveButton(R.string.start,
                            DialogInterface.OnClickListener { dialog, id ->
                                // Send the positive button event back to the
                                // host activity.
                                listener.onDialogPositiveClick(this)
                            })
                    .setNegativeButton(R.string.cancel,
                            DialogInterface.OnClickListener { dialog, id ->
                                // Send the negative button event back to the
                                // host activity.
                                listener.onDialogNegativeClick(this)
                            })

            builder.create()
        } ?: throw IllegalStateException("Activity cannot be null")
    }

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_start_game)
               .setPositiveButton(R.string.start, new DialogInterface.OnClickListener() {
                   public void onClick(DialogInterface dialog, int id) {
                       // Send the positive button event back to the host activity.
                       listener.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.
                       listener.onDialogNegativeClick(NoticeDialogFragment.this);
                   }
               });
        return builder.create();
    }
}

Menampilkan dialog

Jika Anda ingin menampilkan dialog, buat sebuah instance DialogFragment dan telepon show(), meneruskan FragmentManager dan nama tag untuk fragmen dialog tersebut.

Anda bisa mendapatkan FragmentManager dengan memanggil getSupportFragmentManager() dari FragmentActivity atau dengan memanggil getParentFragmentManager() dari Fragment. Lihat contoh berikut:

fun confirmStartGame() {
    val newFragment = StartGameDialogFragment()
    newFragment.show(supportFragmentManager, "game")
}

public void confirmStartGame() {
    DialogFragment newFragment = new StartGameDialogFragment();
    newFragment.show(getSupportFragmentManager(), "game");
}

Argumen kedua, "game", adalah nama tag unik yang digunakan sistem untuk menyimpan dan memulihkan status fragmen jika diperlukan. Tag tersebut juga memungkinkan Anda mendapatkan handle ke fragmen dengan memanggil findFragmentByTag().

Menampilkan dialog layar penuh atau sebagai fragmen yang disematkan

Anda mungkin ingin bagian desain UI Anda muncul sebagai dialog di beberapa sebagai layar penuh atau fragmen tersemat di layar lain. Anda mungkin juga ingin tampilannya berbeda tergantung pada ukuran layar perangkat. Tujuan Class DialogFragment menawarkan fleksibilitas untuk melakukannya, karena dapat berperilaku sebagai Fragment yang dapat disematkan.

Namun, Anda tidak dapat menggunakan AlertDialog.Builder atau Dialog objek untuk membangun dialog dalam kasus ini. Jika Anda ingin DialogFragment agar dapat disematkan, tentukan UI dialog dalam lalu muat tata letaknya di onCreateView() .

Berikut adalah contoh DialogFragment yang dapat muncul sebagai dialog atau fragmen yang dapat disematkan, menggunakan tata letak bernama purchase_items.xml:

class CustomDialogFragment : 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 fun onCreateView(
            inflater: LayoutInflater,
            container: ViewGroup?,
            savedInstanceState: Bundle?
    ): View {
        // Inflate the layout to use as a 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 fun onCreateDialog(savedInstanceState: Bundle): Dialog {
        // The only reason you might override this method when using
        // onCreateView() is to modify the dialog characteristics. For example,
        // the dialog includes a title by default, but your custom layout might
        // not need it. Here, you can remove the dialog title, but you must
        // call the superclass to get the Dialog.
        val dialog = super.onCreateDialog(savedInstanceState)
        dialog.requestWindowFeature(Window.FEATURE_NO_TITLE)
        return dialog
    }
}

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 a 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 the dialog characteristics. For example,
        // the dialog includes a title by default, but your custom layout might
        // not need it. 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;
    }
}

Contoh berikut menentukan apakah akan menampilkan fragmen sebagai dialog atau UI layar penuh, berdasarkan ukuran layar:

fun showDialog() {
    val fragmentManager = supportFragmentManager
    val newFragment = CustomDialogFragment()
    if (isLargeLayout) {
        // 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.
        val transaction = fragmentManager.beginTransaction()
        // For a polished look, 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()
    }
}

public void showDialog() {
    FragmentManager fragmentManager = getSupportFragmentManager();
    CustomDialogFragment newFragment = new CustomDialogFragment();

    if (isLargeLayout) {
        // 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 polished look, 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 cara melakukan transaksi fragmen, lihat Fragmen.

Dalam contoh ini, boolean mIsLargeLayout menentukan apakah perangkat saat ini harus menggunakan desain tata letak besar aplikasi dan dengan demikian menampilkan sebagai dialog, bukan layar penuh. Cara terbaik untuk mengatur boolean adalah untuk mendeklarasikan resource bool nilai dengan nilai alternatif resource untuk berbagai ukuran layar. Misalnya, berikut ini adalah dua versi resource 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>

Kemudian, Anda dapat melakukan inisialisasi nilai mIsLargeLayout selama aktivitas onCreate() seperti yang ditunjukkan dalam contoh berikut:

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_main)

    isLargeLayout = resources.getBoolean(R.bool.large_layout)
}

boolean isLargeLayout;

@Override
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    isLargeLayout = getResources().getBoolean(R.bool.large_layout);
}

Menampilkan aktivitas sebagai dialog di perangkat layar besar

Alih-alih menampilkan dialog sebagai UI layar penuh di layar kecil, Anda bisa mendapatkan hasil yang sama dengan menampilkan Activity sebagai dialog pada layar. Pendekatan yang dipilih bergantung pada desain aplikasi, tetapi menunjukkan aktivitas sebagai dialog sering kali berguna saat aplikasi didesain untuk layar dan Anda ingin meningkatkan pengalaman pada tablet dengan menampilkan aktivitas jangka pendek sebagai dialog.

Untuk menampilkan aktivitas sebagai dialog hanya di perangkat layar besar, terapkan metode Theme.Holo.DialogWhenLarge tema ke elemen manifes <activity>:

<activity android:theme="@android:style/Theme.Holo.DialogWhenLarge" >

Untuk informasi selengkapnya tentang menata gaya aktivitas Anda dengan tema, lihat Gaya dan tema.

Menutup dialog

Saat pengguna mengetuk tombol tindakan yang dibuat dengan AlertDialog.Builder, sistem akan menutup dialog untuk Anda.

Sistem juga menutup dialog saat pengguna mengetuk item dalam dialog daftar, kecuali jika daftar menggunakan tombol pilihan atau kotak centang. Jika tidak, Anda dapat menutup dialog secara manual dengan memanggil dismiss() pada DialogFragment Anda.

Jika Anda perlu melakukan tindakan tertentu saat dialog menghilang, Anda dapat menerapkan onDismiss() di DialogFragment Anda.

Anda juga bisa membatalkan dialog. Ini adalah acara spesial yang menunjukkan bahwa pengguna meninggalkan dialog tanpa menyelesaikan tugas. Ini terjadi jika pengguna mengetuk tombol Kembali atau mengetuk layar di luar dialog atau jika Anda secara eksplisit memanggil cancel() di Dialog, seperti saat merespons "Batal" tombol di dialog.

Seperti yang ditunjukkan dalam contoh sebelumnya, Anda dapat merespons peristiwa batal dengan menerapkan onCancel() di class DialogFragment.