Ein Dialog ist ein kleines Fenster, in dem der Nutzer aufgefordert wird, eine Entscheidung zu treffen oder zusätzliche Informationen einzugeben. Ein Dialogfeld füllt den Bildschirm nicht aus. Es wird normalerweise für modale Ereignisse verwendet, bei denen Nutzer eine Aktion ausführen müssen, bevor sie fortfahren können.
Die Klasse Dialog ist die Basisklasse für Dialogfelder, instanziiert Dialog jedoch nicht direkt. Verwenden Sie stattdessen eine der folgenden abgeleiteten Klassen:
AlertDialog- Ein Dialogfeld, das einen Titel, bis zu drei Schaltflächen, eine Liste auswählbarer Elemente oder ein benutzerdefiniertes Layout enthalten kann.
DatePickerDialogoderTimePickerDialog- Ein Dialogfeld mit einer vordefinierten Benutzeroberfläche, in dem der Nutzer ein Datum oder eine Uhrzeit auswählen kann.
Diese Klassen definieren den Stil und die Struktur Ihres Dialogfelds. Außerdem benötigen Sie einen DialogFragment als Container für das Dialogfeld. Die DialogFragment-Klasse bietet alle Steuerelemente, die Sie zum Erstellen des Dialogfelds und zum Verwalten der Darstellung benötigen, anstatt Methoden für das Dialog-Objekt aufzurufen.
Wenn Sie das Dialogfeld mit DialogFragment verwalten, werden Lebenszyklusereignisse korrekt verarbeitet, z. B. wenn der Nutzer auf die Schaltfläche „Zurück“ tippt oder den Bildschirm dreht. Mit der Klasse DialogFragment können Sie außerdem die UI des Dialogs als einbettbare Komponente in einer größeren UI wiederverwenden – genau wie bei einer herkömmlichen Fragment – z. B. wenn die UI eines Dialogfelds auf großen und kleinen Bildschirmen unterschiedlich dargestellt werden soll.
In den folgenden Abschnitten dieses Dokuments wird beschrieben, wie ein DialogFragment in Kombination mit einem AlertDialog-Objekt verwendet wird. Informationen zum Erstellen einer Datums- oder Uhrzeitauswahl finden Sie hier.
Dialogfeldfragment erstellen
Sie können eine Vielzahl von Dialogdesigns erstellen, einschließlich benutzerdefinierter Layouts, die unter Material Design-Dialogfelder beschrieben werden. Dazu erweitern Sie DialogFragment und erstellen in der Callback-Methode onCreateDialog() eine AlertDialog.
Hier ist beispielsweise ein einfaches AlertDialog-Element, das in einem DialogFragment verwaltet wird:
Kotlin
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")
}
}
Java
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");
Wenn Sie eine Instanz dieser Klasse erstellen und show() für dieses Objekt aufrufen, wird das Dialogfeld wie in der folgenden Abbildung dargestellt.
Im nächsten Abschnitt finden Sie weitere Informationen dazu, wie Sie die AlertDialog.Builder-APIs zum Erstellen des Dialogfelds verwenden.
Je nachdem, wie komplex das Dialogfeld ist, können Sie eine Vielzahl anderer Callback-Methoden in DialogFragment implementieren, einschließlich aller grundlegenden Lebenszyklusmethoden für Fragmente.
Dialogfeld für Benachrichtigungen erstellen
Mit der AlertDialog-Klasse können Sie verschiedene Dialogdesigns erstellen. Sie ist oft die einzige Klasse, die Sie benötigen. Wie in der folgenden Abbildung dargestellt, gibt es drei Bereiche eines Benachrichtigungsdialogs:
- Titel: Dieser Titel ist optional und wird nur verwendet, wenn der Inhaltsbereich eine detaillierte Nachricht, eine Liste oder ein benutzerdefiniertes Layout enthält. Für eine einfache Nachricht oder Frage ist kein Titel erforderlich.
- Inhaltsbereich:Dieser kann eine Nachricht, eine Liste oder ein anderes benutzerdefiniertes Layout anzeigen.
- Aktionsschaltflächen:Ein Dialogfeld kann bis zu drei Aktionsschaltflächen enthalten.
Die AlertDialog.Builder-Klasse stellt APIs bereit, mit denen Sie ein AlertDialog mit diesen Inhalten, einschließlich eines benutzerdefinierten Layouts, erstellen können.
So erstellen Sie ein AlertDialog:
Kotlin
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()
Java
// 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();
Das vorherige Code-Snippet generiert diesen Dialog:
Schaltflächen hinzufügen
Wenn Sie Aktionsschaltflächen wie in Abbildung 2 hinzufügen möchten, rufen Sie die Methoden setPositiveButton() und setNegativeButton() auf:
Kotlin
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()
Java
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();
Die set...Button()-Methoden erfordern einen Titel für die Schaltfläche, der von einer Stringressource bereitgestellt wird, und eine DialogInterface.OnClickListener, die die Aktion definiert, die ausgeführt werden soll, wenn der Nutzer auf die Schaltfläche tippt.
Es gibt drei Aktionsschaltflächen, die Sie hinzufügen können:
- Positiv: Verwenden Sie diese Option, um die Aktion anzunehmen und fortzufahren (Aktion „OK“).
- Negativ:Hiermit brechen Sie die Aktion ab.
- Neutral: Verwenden Sie diese Option, wenn der Nutzer die Aktion möglicherweise nicht fortsetzen, aber nicht abbrechen möchte. Sie wird zwischen den positiven und negativen Schaltflächen eingefügt. Die Aktion könnte beispielsweise „Später erinnern“ lauten.
Sie können nur jeweils einen Schaltflächentyp zu einem AlertDialog hinzufügen. Beispielsweise darf es nicht mehr als eine positive Schaltfläche geben.
Im vorherigen Code-Snippet wird ein Benachrichtigungsdialogfeld angezeigt, das in etwa so aussieht:
Listen hinzufügen
Bei den AlertDialog-APIs sind drei Arten von Listen verfügbar:
- Eine traditionelle Single-Choice-Liste.
- Eine persistente Single-Choice-Liste (Optionsschaltflächen)
- Eine dauerhafte Multiple-Choice-Liste (Kontrollkästchen).
Zum Erstellen einer Single-Choice-Liste wie in Abbildung 5 verwenden Sie die Methode setItems():
Kotlin
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()
Java
@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();
}
Dieses Code-Snippet generiert ein Dialogfeld, das in etwa so aussieht:
Da die Liste im Inhaltsbereich des Dialogfelds angezeigt wird, können darin nicht sowohl eine Nachricht als auch eine Liste angezeigt werden. Legen Sie mit setTitle() einen Titel für das Dialogfeld fest.
Um die Elemente für die Liste anzugeben, rufen Sie setItems() auf und übergeben ein Array. Alternativ können Sie mit setAdapter() eine Liste angeben.
So können Sie die Liste mithilfe eines ListAdapter mit dynamischen Daten stützen, z. B. aus einer Datenbank.
Wenn Sie Ihre Liste mit einem ListAdapter-Element sichern, verwenden Sie immer ein Loader-Element, damit der Inhalt asynchron geladen wird. Dies wird unter Layouts mit einem Adapter erstellen und Ladeprogramme näher beschrieben.
Eine dauerhafte Multiple-Choice- oder Single-Choice-Liste hinzufügen
Verwenden Sie die Methoden setMultiChoiceItems() bzw. setSingleChoiceItems(), um eine Liste mit Multiple-Choice-Elementen (Kästchen) oder Elementen mit einfacher Auswahl (Optionsschaltflächen) hinzuzufügen.
So können Sie beispielsweise eine Multiple-Choice-Liste wie die in Abbildung 6 gezeigte erstellen, mit der die ausgewählten Elemente in einem ArrayList gespeichert werden:
Kotlin
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()
Java
@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();
}
Ein Benachrichtigungsdialogfeld mit einer Auswahlmöglichkeit kann folgendermaßen aufgerufen werden:
Kotlin
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()
Java
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();
Daraus ergibt sich das folgende Beispiel:
Benutzerdefiniertes Layout erstellen
Wenn Sie ein benutzerdefiniertes Layout in einem Dialogfeld verwenden möchten, erstellen Sie ein Layout und fügen Sie es einem AlertDialog hinzu. Rufen Sie dazu setView() für Ihr AlertDialog.Builder-Objekt auf.
Standardmäßig füllt das benutzerdefinierte Layout das Dialogfeld aus. Sie können jedoch weiterhin mit AlertDialog.Builder-Methoden Schaltflächen und einen Titel hinzufügen.
Hier ist beispielsweise die Layoutdatei für das vorherige Layout des benutzerdefinierten Dialogfelds:
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>
Um das Layout in DialogFragment zu erhöhen, rufen Sie einen LayoutInflater mit getLayoutInflater() ab und rufen Sie inflate() auf.
Der erste Parameter ist die Layout-Ressourcen-ID und der zweite Parameter ist eine übergeordnete Ansicht für das Layout. Sie können dann setView() aufrufen, um das Layout im Dialogfeld zu platzieren. Dies wird im folgenden Beispiel dargestellt.
Kotlin
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")
}
Java
@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();
}
Wenn Sie ein benutzerdefiniertes Dialogfeld verwenden möchten, können Sie anstelle der Dialog APIs stattdessen ein Activity als Dialogfeld anzeigen lassen. Erstellen Sie eine Aktivität und legen Sie ihr Design im Manifestelement <activity> auf Theme.Holo.Dialog fest:
<activity android:theme="@android:style/Theme.Holo.Dialog" >
Die Aktivität wird jetzt in einem Dialogfeld statt im Vollbildmodus angezeigt.
Ereignisse an den Host des Dialogfelds zurückgeben
Wenn der Nutzer auf eine der Aktionsschaltflächen des Dialogfelds tippt oder ein Element aus der Liste auswählt, führt DialogFragment möglicherweise die erforderliche Aktion selbst aus. Häufig soll das Ereignis jedoch an die Aktivität oder das Fragment übergeben werden, das bzw. das das Dialogfeld öffnet. Dazu definieren Sie eine Schnittstelle mit einer Methode für jeden Klickereignistyp. Implementieren Sie dann diese Schnittstelle in der Hostkomponente, die die Aktionsereignisse aus dem Dialogfeld empfängt.
Im Folgenden sehen Sie beispielsweise ein DialogFragment, das eine Schnittstelle definiert, über die die Ereignisse an die Hostaktivität zurückgesendet werden:
Kotlin
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"))
}
}
}
Java
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");
}
}
...
}
Die Aktivität, in der das Dialogfeld gehostet wird, erstellt eine Instanz des Dialogfelds mit dem Konstruktor des Dialogfragments und empfängt die Ereignisse des Dialogfelds über eine Implementierung der NoticeDialogListener-Schnittstelle:
Kotlin
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.
}
}
Java
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.
...
}
}
Da die Hostaktivität die NoticeDialogListener implementiert, die von der im vorherigen Beispiel gezeigten Callback-Methode onAttach() erzwungen wird, kann das Dialogfeldfragment die Callback-Methoden der Schnittstelle verwenden, um Klickereignisse an die Aktivität zu senden:
Kotlin
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")
}
Java
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();
}
}
Dialogfeld anzeigen
Wenn das Dialogfeld angezeigt werden soll, erstellen Sie eine Instanz von DialogFragment und rufen show() auf. Übergeben Sie dabei das FragmentManager und einen Tag-Namen für das Dialogfragment.
Du kannst das FragmentManager abrufen, indem du getSupportFragmentManager() aus dem FragmentActivity oder getParentFragmentManager() aus einer Fragment aufrufst. Hier ein Beispiel:
Kotlin
fun confirmStartGame() {
val newFragment = StartGameDialogFragment()
newFragment.show(supportFragmentManager, "game")
}
Java
public void confirmStartGame() {
DialogFragment newFragment = new StartGameDialogFragment();
newFragment.show(getSupportFragmentManager(), "game");
}
Das zweite Argument ("game") ist ein eindeutiger Tag-Name, den das System verwendet, um den Fragmentstatus zu speichern und bei Bedarf wiederherzustellen. Mit dem Tag können Sie auch einen Handle zum Fragment abrufen, indem Sie findFragmentByTag() aufrufen.
Dialogfeld im Vollbildmodus oder als eingebettetes Fragment anzeigen
Es kann sein, dass ein Teil Ihres UI-Designs in einigen Situationen als Dialogfeld und in anderen als Vollbild oder als eingebettetes Fragment angezeigt wird. Möglicherweise möchten Sie auch, dass es je nach Bildschirmgröße des Geräts unterschiedlich angezeigt wird. Die Klasse DialogFragment bietet hierfür Flexibilität, da sie sich als einbettbares Fragment verhalten kann.
Sie können in diesem Fall jedoch kein AlertDialog.Builder oder andere Dialog-Objekte zum Erstellen des Dialogfelds verwenden. Wenn das DialogFragment einbettbar sein soll, definieren Sie die UI des Dialogfelds in einem Layout und laden Sie das Layout dann im onCreateView()-Callback.
Hier ist ein Beispiel für DialogFragment, das als Dialogfeld oder einbettbares Fragment mit einem Layout namens purchase_items.xml angezeigt werden kann:
Kotlin
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
}
}
Java
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;
}
}
Im folgenden Beispiel wird je nach Bildschirmgröße bestimmt, ob das Fragment als Dialogfeld oder als Vollbild-UI angezeigt wird:
Kotlin
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()
}
}
Java
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();
}
}
Weitere Informationen zum Ausführen von Fragmenttransaktionen finden Sie unter Fragmente.
In diesem Beispiel gibt der boolesche Wert mIsLargeLayout an, ob das aktuelle Gerät das große Layoutdesign der App verwenden muss und dieses Fragment daher als Dialogfeld statt im Vollbildmodus angezeigt werden soll. Am besten legen Sie diese Art von booleschem Wert fest, indem Sie einen boolen Ressourcenwert mit einem alternativen Ressourcenwert für verschiedene Bildschirmgrößen deklarieren. Hier sind zum Beispiel zwei Versionen der booleschen Ressource für verschiedene Bildschirmgrößen:
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>
Anschließend können Sie den Wert mIsLargeLayout während der Methode onCreate() der Aktivität initialisieren, wie im folgenden Beispiel gezeigt:
Kotlin
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
isLargeLayout = resources.getBoolean(R.bool.large_layout)
}
Java
boolean isLargeLayout;
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
isLargeLayout = getResources().getBoolean(R.bool.large_layout);
}
Aktivität als Dialogfeld auf großen Bildschirmen anzeigen
Anstatt ein Dialogfeld auf kleinen Bildschirmen als Vollbild-UI einzublenden, erhalten Sie dasselbe Ergebnis, wenn Sie auf großen Bildschirmen ein Activity als Dialogfeld anzeigen. Der Ansatz, den Sie wählen, hängt vom Design Ihrer App ab. Das Einblenden einer Aktivität als Dialogfeld ist jedoch oft nützlich, wenn Ihre App für kleine Bildschirme entwickelt wurde und Sie die Nutzerfreundlichkeit auf Tablets verbessern möchten, indem Sie eine kurzlebige Aktivität als Dialog einblenden.
Wenn Sie eine Aktivität nur auf großen Bildschirmen als Dialogfeld anzeigen möchten, wenden Sie das Design Theme.Holo.DialogWhenLarge auf das Manifestelement <activity> an:
<activity android:theme="@android:style/Theme.Holo.DialogWhenLarge" >
Weitere Informationen dazu, wie Sie Ihre Aktivitäten mithilfe von Designs gestalten, finden Sie unter Stile und Designs.
Dialogfeld schließen
Wenn der Nutzer auf eine Aktionsschaltfläche tippt, die mit einem AlertDialog.Builder erstellt wurde, schließt das System das Dialogfeld für dich.
Das Dialogfeld wird auch geschlossen, wenn der Nutzer in einer Dialogfeldliste auf ein Element tippt, es sei denn, in der Liste werden Optionsfelder oder Kästchen verwendet. Andernfalls können Sie das Dialogfeld manuell schließen, indem Sie dismiss() auf Ihrem DialogFragment aufrufen.
Wenn Sie nach dem Schließen des Dialogfelds bestimmte Aktionen ausführen müssen, können Sie die Methode onDismiss() in Ihrem DialogFragment implementieren.
Sie können ein Dialogfeld auch abbrechen. Dies ist ein spezielles Ereignis, das darauf hinweist, dass der Nutzer das Dialogfeld verlässt, ohne die Aufgabe abzuschließen. Das passiert, wenn der Nutzer auf die Schaltfläche „Zurück“ oder außerhalb des Dialogfeldbereichs auf den Bildschirm tippt oder wenn Sie cancel() für das Dialog explizit aufrufen, z. B. als Antwort auf die Schaltfläche „Abbrechen“ im Dialogfeld.
Wie im vorherigen Beispiel gezeigt, können Sie auf das Abbruchereignis reagieren, indem Sie onCancel() in Ihrer DialogFragment-Klasse implementieren.