Wie kann ich die Breite und Höhe von DialogFragment einstellen?

Am Ende überschrieb ich Fragment.onResume() und holte mir die Attribute aus dem darunter liegenden Dialog und stellte dort Breite/Höhe-Parameter ein. Ich setze die äußerste Layouthöhe/-breite auf match_parent. Beachten Sie, dass dieser Code auch die Ränder zu beachten scheint, die ich im XML-Layout definiert habe.

@Override
public void onResume() {
    super.onResume();
    ViewGroup.LayoutParams params = getDialog().getWindow().getAttributes();
    params.width = LayoutParams.MATCH_PARENT;
    params.height = LayoutParams.MATCH_PARENT;
    getDialog().getWindow().setAttributes((Android.view.WindowManager.LayoutParams) params);
}

Ich habe eine DialogFragment-Größe mit fester Größe, die im XML-Hauptlayout (in meinem Fall LinearLayout) Folgendes definiert:

Android:layout_width="match_parent"
Android:layout_height="match_parent"
Android:minWidth="1000dp"
Android:minHeight="450dp"

Das Einzige, was in meinem Fall funktioniert hat, war die hier angegebene Lösung: http://adilatwork.blogspot.mx/2012/11/Android-dialogfragment-dialog-sizing.html

Ausschnitt aus Adil-Blogbeitrag:

@Override
public void onStart()
{
  super.onStart();

  // safety check
  if (getDialog() == null)
    return;

  int dialogWidth = ... // specify a value here
  int dialogHeight = ... // specify a value here

  getDialog().getWindow().setLayout(dialogWidth, dialogHeight);

  // ... other stuff you want to do in your onStart() method
}

Sie können die Breite und Höhe Ihrer DialogFragment steuern, indem Sie sicherstellen, dass das Dialogfeld die Breite und Höhe Ihrer Ansicht berücksichtigt, wenn deren Wert WRAP_CONTENT ist.

ThemeOverlay.AppCompat.Dialog verwenden

Eine einfache Möglichkeit, dies zu erreichen, besteht darin, den in der Android Support Library enthaltenen ThemeOverlay.AppCompat.Dialog-Stil zu verwenden.

DialogFragment mit Dialog:

@NonNull
@Override
public Dialog onCreateDialog(Bundle savedInstanceState) {
    LayoutInflater inflater = LayoutInflater.from(getContext());
    View view = inflater.inflate(R.layout.dialog_view, null);

    Dialog dialog = new Dialog(getContext(), R.style.ThemeOverlay_AppCompat_Dialog);
    dialog.setContentView(view);
    return dialog;
}

DialogFragment mit AlertDialog (Einschränkung: minHeight="48dp"):

@NonNull
@Override
public Dialog onCreateDialog(Bundle savedInstanceState) {
    LayoutInflater inflater = LayoutInflater.from(getContext());
    View view = inflater.inflate(R.layout.dialog_view, null);

    AlertDialog.Builder builder = new AlertDialog.Builder(getContext(), R.style.ThemeOverlay_AppCompat_Dialog);
    builder.setView(view);
    return builder.create();
}

Sie können auch ThemeOverlay.AppCompat.Dialog als Standarddesign festlegen, wenn Sie Ihre Dialoge erstellen, indem Sie es dem XML-Design Ihrer App hinzufügen.
Seien Sie vorsichtig, da viele Dialoge die Standard-Mindestbreite benötigen, um gut auszusehen.

<!-- Base application theme. -->
<style name="AppTheme" parent="Theme.AppCompat.Light.DarkActionBar">
    <!-- For Android Dialog. -->
    <item name="Android:dialogTheme">@style/ThemeOverlay.AppCompat.Dialog</item>

    <!-- For Android AlertDialog. -->
    <item name="Android:alertDialogTheme">@style/ThemeOverlay.AppCompat.Dialog</item>

    <!-- For AppCompat AlertDialog. -->
    <item name="alertDialogTheme">@style/ThemeOverlay.AppCompat.Dialog</item>

    <!-- Other attributes. -->
</style>

DialogFragment mit Dialog unter Verwendung von Android:dialogTheme:

@NonNull
@Override
public Dialog onCreateDialog(Bundle savedInstanceState) {
    LayoutInflater inflater = LayoutInflater.from(getContext());
    View view = inflater.inflate(R.layout.dialog_view, null);

    Dialog dialog = new Dialog(getContext());
    dialog.setContentView(view);
    return dialog;
}

DialogFragment mit AlertDialog, unter Verwendung von Android:alertDialogTheme oder alertDialogTheme (Einschränkung: minHeight="48dp"):

@NonNull
@Override
public Dialog onCreateDialog(Bundle savedInstanceState) {
    LayoutInflater inflater = LayoutInflater.from(getContext());
    View view = inflater.inflate(R.layout.dialog_view, null);

    AlertDialog.Builder builder = new AlertDialog.Builder(getContext());
    builder.setView(view);
    return builder.create();
}

Bonus

Bei älteren Android-APIs scheinen Dialogs aufgrund ihres Titels einige Probleme mit der Breite zu haben (auch wenn Sie keine festlegen).
Wenn Sie nicht ThemeOverlay.AppCompat.Dialog style verwenden möchten und Ihre Dialog keinen Titel benötigt (oder einen benutzerdefinierten hat), möchten Sie ihn möglicherweise deaktivieren:

@NonNull
@Override
public Dialog onCreateDialog(Bundle savedInstanceState) {
    LayoutInflater inflater = LayoutInflater.from(getContext());
    View view = inflater.inflate(R.layout.dialog_view, null);

    Dialog dialog = new Dialog(getContext());
    dialog.requestWindowFeature(Window.FEATURE_NO_TITLE);
    dialog.setContentView(view);
    return dialog;
}

Veraltete Antwort, funktioniert in den meisten Fällen nicht

_{Ich habe versucht, den Dialog der Breite und Höhe meines Layouts anzupassen, ohne programmgesteuert eine feste Größe anzugeben.}

_{Ich dachte mir, dass Android:windowMinWidthMinor und Android:windowMinWidthMajor das Problem verursachen. Obwohl sie nicht in das Thema meiner Activity oder Dialog aufgenommen wurden, wurden sie trotzdem irgendwie auf das Activity-Design angewendet.}

_{Ich habe drei mögliche Lösungen gefunden.}

_{Lösung 1: Erstellen Sie ein benutzerdefiniertes Dialogdesign und verwenden Sie es beim Erstellen des Dialogs in der Variablen DialogFragment.}

<style name="Theme.Material.Light.Dialog.NoMinWidth" parent="Android:Theme.Material.Light.Dialog">
    <item name="Android:windowMinWidthMinor">0dip</item>
    <item name="Android:windowMinWidthMajor">0dip</item>
</style>

@Override
public Dialog onCreateDialog(Bundle savedInstanceState) {
    return new Dialog(getActivity(), R.style.Theme_Material_Light_Dialog_NoMinWidth);
}

_{Lösung 2: Erstellen Sie ein benutzerdefiniertes Design, das in einer ContextThemeWrapper verwendet werden soll, die als Context für den Dialog dienen soll. Verwenden Sie diese Option, wenn Sie kein benutzerdefiniertes Dialogdesign erstellen möchten (z. B. wenn Sie das mit Android:dialogTheme angegebene Design verwenden möchten).}

<style name="Theme.Window.NoMinWidth" parent="">
    <item name="Android:windowMinWidthMinor">0dip</item>
    <item name="Android:windowMinWidthMajor">0dip</item>
</style>

@Override
public Dialog onCreateDialog(Bundle savedInstanceState) {
    return new Dialog(new ContextThemeWrapper(getActivity(), R.style.Theme_Window_NoMinWidth), getTheme());
}

_{Lösung 3 (mit einer AlertDialog): erzwinge Android:windowMinWidthMinor und Android:windowMinWidthMajor in die ContextThemeWrapper, die durch den AlertDialog$Builder erstellt wurde.}

<style name="Theme.Window.NoMinWidth" parent="">
    <item name="Android:windowMinWidthMinor">0dip</item>
    <item name="Android:windowMinWidthMajor">0dip</item>
</style>

@Override
public final Dialog onCreateDialog(Bundle savedInstanceState) {
    View view = new View(); // Inflate your view here.
    AlertDialog.Builder builder = new AlertDialog.Builder(getActivity());
    builder.setView(view);
    // Make sure the dialog width works as WRAP_CONTENT.
    builder.getContext().getTheme().applyStyle(R.style.Theme_Window_NoMinWidth, true);
    return builder.create();
}

Gotcha # 13: DialogFragment Layouts

Es ist irgendwie geistesabwesend.

Beim Erstellen einer DialogFragment können Sie onCreateView (die eine ViewGroup zum Übergeben Ihres XML-Layouts übergibt) oder onCreateDialog überschreiben, was nicht der Fall ist.

Beide Methoden dürfen nicht außer Kraft gesetzt werden, da Android wahrscheinlich __ verwirrt wird. wann oder ob das Layout Ihres Dialogs aufgeblasen wurde! WTF?

Die Wahl, ob Sie OnCreateDialog oder OnCreateView überschreiben möchten, hängt davon ab, wie Sie das Dialogfeld verwenden möchten.

• Wenn Sie den Dialog in einem Fenster starten (normales Verhalten), wird erwartet, dass Sie OnCreateDialog überschreiben.
• Wenn Sie das Dialogfragment in ein vorhandenes UI-Layout einbetten möchten (weit weniger verbreitet), müssen Sie OnCreateView überschreiben.

Dies ist möglicherweise das Schlimmste auf der Welt.

onCreateDialog Wahnsinn

Sie überschreiben also onCreateDialog in Ihrer DialogFragment, um eine benutzerdefinierte Instanz von AlertDialog für die Anzeige in einem Fenster zu erstellen. Cool. Denken Sie jedoch daran, dass onCreateDialog keine ViewGroup empfängt, um Ihr benutzerdefiniertes XML-Layout an anzuhängen. Kein Problem, Sie übergeben einfach null an die inflate-Methode.

Lasst den Wahnsinn beginnen.

Wenn Sie onCreateDialog überschreiben, werden mehrere Attribute des Wurzelknotens des XML-Layouts, das Sie aufpumpen, von Android COMPLETELY IGNORES . Dies beinhaltet, ist aber wahrscheinlich nicht beschränkt auf:

• background_color
• layout_gravity
• layout_width
• layout_height

Das ist fast komisch, da Sie layout_width und layout_height von JEDEM .xml-Layout oder Android Studio einstellen müssen, um Sie mit einem kleinen, kleinen roten Zeichen der Schande zu schlagen.

Nur die WordDialogFragment lässt mich kotzen. Ich könnte einen Roman schreiben, der mit Android-Gotchas und Snafus gefüllt ist, aber dieser ist einer der innigsten.

Um zur Vernunft zurückzukehren, deklarieren wir zunächst einen Stil, um JUST den background_color und layout_gravity wiederherzustellen, die wir erwarten:

<style name="MyAlertDialog" parent="Theme.AppCompat.Dialog">
    <item name="Android:windowBackground">@Android:color/transparent</item>
    <item name="Android:layout_gravity">center</item>
</style>

Der Stil oben erbt vom Basisthema für Dialoge (in diesem Beispiel im Thema AppCompat).

Als Nächstes wende wir den Stil programmgesteuert an, um die Werte, die Android gerade beiseite geschoben hat, zurückzusetzen und das standardmäßige AlertDialog-Erscheinungsbild wiederherzustellen:

public class MyDialog extends DialogFragment {
    @Override
    public Dialog onCreateDialog(Bundle savedInstanceState) {
        View layout = getActivity().getLayoutInflater().inflate(R.layout.my_dialog_layout, null, false);
        assert layout != null;
        //build the alert dialog child of this fragment
        AlertDialog.Builder b = new AlertDialog.Builder(getActivity());
        //restore the background_color and layout_gravity that Android strips
        b.getContext().getTheme().applyStyle(R.style.MyAlertDialog, true);
        b.setView(layout);
        return b.create();
    }
}

Der obige Code lässt Ihre AlertDialog wieder wie eine AlertDialog aussehen. Vielleicht ist das gut genug.

Aber warte, es gibt noch mehr!

Wenn Sie einen-SPEZIFISCHENlayout_width oder layout_height für Ihre AlertDialog setzen möchten, wenn diese angezeigt wird (sehr wahrscheinlich), dann raten Sie mal, was Sie noch nicht getan haben!

Der Spaß wird fortgesetzt, wenn Sie feststellen, dass Android, wenn Sie versuchen, einen bestimmten layout_width oder layout_height in Ihrem ausgefallenen neuen Stil festzulegen, dies auch völlig ignorieren wird:

<style name="MyAlertDialog" parent="Theme.AppCompat.Dialog">
    <item name="Android:windowBackground">@Android:color/transparent</item>
    <item name="Android:layout_gravity">center</item>
    <!-- NOPE!!!!! --->
    <item name="Android:layout_width">200dp</item>
    <!-- NOPE!!!!! --->
    <item name="Android:layout_height">200dp</item>
</style>

Um eine Breite oder Höhe eines SPEZIFISCHEN Fensters festzulegen, können Sie sich mit einer ganz bestimmten Methode beschäftigen und mit LayoutParams umgehen:

@Override
public void onResume() {
    super.onResume();
    Window window = getDialog().getWindow();
    if(window == null) return;
    WindowManager.LayoutParams params = window.getAttributes();
    params.width = 400;
    params.height = 400;
    window.setAttributes(params);
}

Viele Leute folgen Androids schlechtem Beispiel für das Casting WindowManager.LayoutParams bis zum allgemeineren ViewGroup.LayoutParams, nur um rechts herum zu drehen und ViewGroup.LayoutParams wieder ein paar Zeilen später in WindowManager.LayoutParams zu werfen. Wirksames Java sei verdammt, dieses unnötige Casting bietet NICHTS, außer dass der Code noch schwerer zu entschlüsseln ist.

Randbemerkung: Im Android-SDK gibt es einige zwanzigmal Wiederholungen von LayoutParams - ein perfektes Beispiel für radikal schlechtes Design.

In Summe

Für DialogFragments, die onCreateDialog überschreiben:

• Um das standardmäßige Aussehen und Verhalten von AlertDialog wiederherzustellen, erstellen Sie einen Stil, der background_color = transparent und layout_gravity = center setzt, und wenden diesen Stil in onCreateDialog an.
• Um einen bestimmten layout_width und/oder layout_height festzulegen, führen Sie eine programmgesteuerte Änderung in onResume mit LayoutParams durch.
• Um den Verstand zu erhalten, sollten Sie nicht über das Android SDK nachdenken.

Wenn ich das DialogFragment etwas breiter machen muss, stelle ich minWidth ein:

<LinearLayout
    Android:layout_width="match_parent"
    Android:layout_height="match_parent"
    Android:minWidth="320dp"
    ... />

Die Bemaßung im äußersten Layout funktioniert nicht im Dialog. Sie können ein Layout hinzufügen, dessen eingestellte Größe unter dem äußersten liegt.

<RelativeLayout xmlns:Android="http://schemas.Android.com/apk/res/Android"
Android:layout_width="wrap_content"
Android:layout_height="wrap_content">

<LinearLayout
    Android:layout_width="xxdp"
    Android:layout_height="xxdp"
    Android:orientation="vertical">

</LinearLayout>

Ich habe es korrigiert, indem die Parameter für das Wurzelelementlayout festgelegt wurden.

int width = activity.getResources().getDisplayMetrics().widthPixels;
int height = activity.getResources().getDisplayMetrics().heightPixels;
content.setLayoutParams(new LinearLayout.LayoutParams(width, height));

Hier können Sie die Breite/Höhe von DialogFragment in XML festlegen. Packen Sie Ihre viewHierarchy einfach in ein Framelayout (jedes Layout funktioniert) mit einem transparenten Hintergrund. 

Ein transparenter Hintergrund scheint eine besondere Flagge zu sein, da dabei automatisch das untergeordnete Element von frameLayout im Fenster zentriert wird. Hinter dem Fragment wird immer noch der gesamte Bildschirm dunkler, was darauf hinweist, dass Ihr Fragment das aktive Element ist.

<?xml version="1.0" encoding="utf-8"?>
<FrameLayout xmlns:Android="http://schemas.Android.com/apk/res/Android"
    Android:layout_width="match_parent"
    Android:layout_height="match_parent"
    Android:background="@color/transparent">

    <RelativeLayout
        Android:layout_width="match_parent"
        Android:layout_height="300dp"
        Android:background="@color/background_material_light">

      .....

Sie können Prozentsatz für die Breite verwenden.

<style name="Theme.Holo.Dialog.MinWidth">
<item name="Android:windowMinWidthMajor">70%</item>

Ich habe Holo Theme für dieses Beispiel verwendet.

Sie können unterhalb des Codes die Breite und Höhe des Layouts in Java festlegen.

final AlertDialog alertDialog  = alertDialogBuilder.create();
final WindowManager.LayoutParams WMLP = alertDialog.getWindow().getAttributes();

WMLP.gravity = Gravity.TOP;
WMLP.y = mActionBarHeight;
WMLP.x = getResources().getDimensionPixelSize(R.dimen.unknown_image_width);

alertDialog.getWindow().setAttributes(WMLP);
alertDialog.show();

Ich erstelle das Dialogfeld mit AlertDialog.Builder, sodass ich Rodrigos Antwort in einem OnShowListener verwendet habe.

dialog.setOnShowListener(new OnShowListener() {

            @Override
            public void onShow(DialogInterface dialogInterface) {
                Display display = getWindowManager().getDefaultDisplay();
                DisplayMetrics outMetrics = new DisplayMetrics ();
                display.getMetrics(outMetrics);
                dialog.getWindow().setLayout((int)(312 * outMetrics.density), (int)(436 * outMetrics.density));
            }

        });

Bei der Arbeit mit Android 6.0 lief das gleiche Problem. AlertDialog würde standardmäßig die vordefinierte width-Einstellung im Design übernehmen, unabhängig von der tatsächlichen width-Einstellung in der benutzerdefinierten Ansicht Layout. Es gelang mir, die Einstellung der width der loading_messageTextView richtig einzustellen. Ohne weiter zu untersuchen, scheint es, als würde die Größenänderung der tatsächlichen Elemente und das Umwickeln der Wurzel Layout dazu führen, dass es wie erwartet funktioniert. Nachfolgend finden Sie ein XML-Layout eines Ladedialogs, das width des Dialogs richtig setzt. Verwenden der dieser Bibliothek für die Animation.

<RelativeLayout
    xmlns:Android="http://schemas.Android.com/apk/res/Android"
    Android:layout_width="wrap_content"
    Android:layout_height="wrap_content"
    Android:background="@color/custom_color"
    Android:padding="@dimen/custom_dimen">
    <com.github.rahatarmanahmed.cpv.CircularProgressView
        xmlns:app="http://schemas.Android.com/apk/res-auto"
        Android:id="@+id/progress_view"
        Android:layout_width="40dp"
        Android:layout_height="40dp"
        Android:layout_centerHorizontal="true"
        app:cpv_color="@color/white"
        app:cpv_animAutostart="true"
        app:cpv_indeterminate="true" />
    <TextView
        Android:id="@+id/loading_message"
        Android:layout_width="100dp"
        Android:layout_height="wrap_content"
        Android:layout_below="@+id/progress_view"
        Android:layout_centerHorizontal="true"
        Android:gravity="center"
        Android:textSize="18dp"
        Android:layout_marginTop="@dimen/custom_dimen"
        Android:textColor="@color/white"
        Android:text="@string/custom_string"/>
</RelativeLayout>

Ich sehe keinen zwingenden Grund, onResume oder onStart zu überschreiben, um die Breite und Höhe von Window innerhalb von DialogFragments Dialog festzulegen. Diese bestimmten Lebenszyklusmethoden können wiederholt aufgerufen werden und führen dazu, dass der Änderungscode mehrmals wiederholt wird, beispielsweise durch ein Mehrfachfenster Umschalten, Backgrounding, dann Vordergrund der App usw. Die Konsequenzen dieser Wiederholung sind ziemlich trivial, aber warum sollte man sich damit zufrieden geben?

Das Festlegen der Breite/Höhe stattdessen innerhalb einer überschriebenen onActivityCreated()-Methode ist eine Verbesserung, da diese Methode nur einmal pro Instanz Ihrer DialogFragment aufgerufen wird. Zum Beispiel:

@Override
public void onActivityCreated(Bundle savedInstanceState) {
    super.onActivityCreated(savedInstanceState);

    Window window = getDialog().getWindow();
    assert window != null;

    WindowManager.LayoutParams layoutParams = window.getAttributes();
    layoutParams.width = ViewGroup.LayoutParams.MATCH_PARENT;
    window.setAttributes(layoutParams);
}

Oben habe ich nur die Breite so eingestellt, dass match_parent unabhängig von der Geräteorientierung ist. Wenn Sie möchten, dass Ihr Landschaftsdialogfeld nicht so breit ist, können Sie vorher prüfen, ob getResources().getConfiguration().orientation == Configuration.ORIENTATION_PORTRAIT.

Legen Sie das übergeordnete Layout des benutzerdefinierten Dialoglayouts auf RelativeLayout fest und erhalten Sie automatisch Breite und Höhe.

<RelativeLayout xmlns:Android="http://schemas.Android.com/apk/res/Android"
Android:layout_width="match_parent"
Android:layout_height="match_parent">

Einfach und solide:

@Override
    public void onResume() {
        // Sets the height and the width of the DialogFragment
        int width = ConstraintLayout.LayoutParams.MATCH_PARENT;
        int height = ConstraintLayout.LayoutParams.MATCH_PARENT;
        getDialog().getWindow().setLayout(width, height);

        super.onResume();
    }

Dies ist die einfachste Lösung

Die beste Lösung, die ich gefunden habe, ist, onCreateDialog() anstelle von onCreateView() zu überschreiben. setContentView () setzt die korrekten Fensterabmessungen vor dem Aufblasen. Sie müssen keine Bemaßung, Hintergrundfarbe, Stil usw. in Ressourcendateien speichern/festlegen und manuell einstellen.

@Override
public Dialog onCreateDialog(Bundle savedInstanceState) {
    Dialog dialog = new Dialog(getActivity());
    dialog.setContentView(R.layout.fragment_dialog);

    Button button = (Button) dialog.findViewById(R.id.dialog_button);
    // ...
    return dialog;
}

In meinem Fall wurde es durch align_parentBottom="true" verursacht, der einer Ansicht innerhalb einer RelativeLayout gegeben wurde. Alle alignParentBottoms wurden entfernt und alle Layouts in vertikale LinearLayouts geändert und das Problem wurde behoben. 

Fügen Sie zu Ihrem FragmentDialog hinzu:

public void onResume() {
    Window window = getDialog().getWindow();
    Point size = new Point();
    Display display = window.getWindowManager().getDefaultDisplay();
    display.getSize(size);
    window.setLayout( (int)(size.x * 0.9), WindowManager.LayoutParams.WRAP_CONTENT );
    window.setGravity( Gravity.CENTER );
    super.onResume();
}

@Override
public void onStart() {
    super.onStart();
    Dialog dialog = getDialog();
    if (dialog != null)
    {
        dialog.getWindow().setLayout(-1, -2);
        dialog.getWindow().getAttributes().windowAnimations = R.style.DialogAnimation;
        Window window = getDialog().getWindow();
        WindowManager.LayoutParams params = window.getAttributes();
        params.dimAmount = 1.0f;
        window.setAttributes(params);
        window.setBackgroundDrawableResource(Android.R.color.transparent);
    }
}

Eine der früheren Lösungen hat beinahe funktioniert. Ich habe etwas anderes ausprobiert und es hat für mich gearbeitet.

(Stellen Sie sicher, dass Sie sich seine Lösung ansehen.) Dies war seine Lösung .. Klicken Sie hier Es hat funktioniert, außer: builder.getContext (). GetTheme (). ApplyStyle (R.style.Theme_Window_NoMinWidth, wahr);

Ich habe es geändert 

 @Override
    public Dialog onCreateDialog(Bundle savedInstanceState) {


        // Use the Builder class for convenient dialog construction
        AlertDialog.Builder builder = new AlertDialog.Builder(getActivity());

        // Get layout inflater
        LayoutInflater layoutInflater = getActivity().getLayoutInflater();

        // Set layout by setting view that is returned from inflating the XML layout
        builder.setView(layoutInflater.inflate(R.layout.dialog_window_layout, null));


        AlertDialog dialog = builder.create();

        dialog.getContext().setTheme(R.style.Theme_Window_NoMinWidth);

Die letzte Zeile ist, was wirklich anders ist.