Określam układ mojego DialogFragment w pliku układu xml (nazwijmy go layout_mydialogfragment.xml), a szczególnie jego atrybuty layout_widthi layout_height( 100dppowiedzmy każdy). Następnie zawyżam ten układ w metodzie DialogFragment w onCreateView(...)następujący sposób:

View view = inflater.inflate(R.layout.layout_mydialogfragment, container, false);

Niestety stwierdzam, że kiedy pojawia się moje okno dialogowe (DialogFragment), nie jest ono zgodne z layout_widthi layout_heightokreślone w jego pliku układu xml (a moje okno dialogowe zmniejsza się lub rozszerza w zależności od zawartości). Czy ktoś wie, czy lub jak mogę sprawić, by moje okno dialogowe przestrzegało layout_widthi layout_heightokreślone w pliku układu XML? W tej chwili muszę ponownie określić szerokość i wysokość mojego okna dialogowego w metodzie mojego DialogFragment w onResume()następujący sposób ...

getDialog().getWindow().setLayout(width, height);

... A zatem, niechcący, należy pamiętać o przyszłych zmianach szerokości i wysokości okna dialogowego w dwóch miejscach.

Jeśli konwertujesz bezpośrednio z wartości zasobów:

int width = getResources().getDimensionPixelSize(R.dimen.popup_width);
int height = getResources().getDimensionPixelSize(R.dimen.popup_height);        
getDialog().getWindow().setLayout(width, height);

Następnie określ match_parent w swoim układzie okna dialogowego:

android:layout_width="match_parent"
android:layout_height="match_parent"

Musisz martwić się tylko o jedno miejsce (umieść je w swoim DialogFragment#onResume). Nie jest doskonały, ale przynajmniej działa w przypadku posiadania RelativeLayout jako katalogu głównego pliku układu twojego okna dialogowego.

Skończyło się na nadpisywaniu Fragment.onResume()i przechwytywaniu atrybutów z podstawowego okna dialogowego, a następnie ustawianiu tam parametrów szerokości / wysokości. Ustawiłem zewnętrzną wysokość / szerokość układu na match_parent. Zauważ, że ten kod wydaje się uwzględniać również marginesy, które zdefiniowałem w układzie XML.

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

Mam stały rozmiar DialogFragment definiujący następujące elementy w głównym układzie XML (w moim przypadku LinearLayout):

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

Jedyne, co zadziałało w moim przypadku, to rozwiązanie wskazane tutaj: http://adilatwork.blogspot.mx/2012/11/android-dialogfragment-dialog-sizing.html

Fragment z posta na blogu Adil:

@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
}

Jednym ze sposobów kontrolowania DialogFragmentszerokości i wysokości jest upewnienie się, że okno dialogowe uwzględnia szerokość i wysokość widoku, jeśli ich wartość to WRAP_CONTENT.

Za pomocą ThemeOverlay.AppCompat.Dialog

Prostym sposobem na osiągnięcie tego jest użycie ThemeOverlay.AppCompat.Dialogstylu zawartego w bibliotece obsługi systemu Android.

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

DialogFragmentz AlertDialog(zastrzeżenie:) 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();
}

Możesz także ustawić ThemeOverlay.AppCompat.Dialogjako domyślny motyw podczas tworzenia okien dialogowych, dodając go do motywu xml swojej aplikacji.
Uważaj, ponieważ wiele okien dialogowych wymaga domyślnej minimalnej szerokości, aby dobrze wyglądać.

<!-- 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>

DialogFragmentz Dialogwykorzystaniem 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;
}

DialogFragmentz AlertDialog, korzystając z android:alertDialogThemeor alertDialogTheme(ostrzeżenie:) 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();
}

Premia

W starszych interfejsach API systemu Android Dialogwydaje się, że mają pewne problemy z szerokością, ze względu na ich tytuł (nawet jeśli go nie ustawisz).
Jeśli nie chcesz używać ThemeOverlay.AppCompat.Dialogstylu i Dialognie potrzebujesz tytułu (lub masz niestandardowy), możesz go wyłączyć:

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

Nieaktualna odpowiedź, w większości przypadków nie zadziała

_{Starałem się, aby okno dialogowe uwzględniało szerokość i wysokość mojego układu, bez programowego określania stałego rozmiaru.}

_{Doszedłem do tego android:windowMinWidthMinori android:windowMinWidthMajorspowodowałem problem. Mimo że nie były one zawarte w temacie mojego Activitylub , w jakiś sposób Dialognadal były do ​​niego stosowane Activity.}

_{Wymyśliłem trzy możliwe rozwiązania.}

_{Rozwiązanie 1: utwórz niestandardowy motyw okna dialogowego i użyj go podczas tworzenia okna dialogowego w 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);
}

_{Rozwiązanie 2: stworzenie własnego motywu być używany w ContextThemeWrapperktóre będą służyć jako Contextdla okna. Użyj tego, jeśli nie chcesz tworzyć niestandardowego motywu okna dialogowego (na przykład, gdy chcesz użyć motywu określonego przez android:dialogTheme).}

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

_{Rozwiązanie 3 (z AlertDialog): wymuś android:windowMinWidthMinori android:windowMinWidthMajordo ContextThemeWrapperutworzonego przez AlertDialog$Builder.}

<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: DialogFragmentLayouts

To naprawdę paraliżujące.

Podczas tworzenia DialogFragmentmożesz wybrać nadpisanie onCreateView(co przekazuje a, ViewGroupaby dołączyć układ .xml) lub onCreateDialog, co nie.

Nie możesz jednak nadpisywać obu metod, ponieważ najprawdopodobniej pomylisz Androida co do tego, kiedy i czy układ twojego okna dialogowego był zawyżony! WTF?

Wybór, czy nadpisać, OnCreateDialogczy OnCreateViewzależy od tego, jak zamierzasz używać okna dialogowego.

• Jeśli otworzysz okno dialogowe w oknie (normalne zachowanie), powinieneś nadpisać OnCreateDialog.
• Jeśli zamierzasz osadzić fragment okna dialogowego w istniejącym układzie interfejsu użytkownika (znacznie rzadziej), należy nadpisać OnCreateView.

To prawdopodobnie najgorsza rzecz na świecie.

onCreateDialog Niepoczytalność

Tak więc nadpisujesz onCreateDialogw swoim, DialogFragmentaby utworzyć niestandardową instancję AlertDialogdo wyświetlenia w oknie. Chłodny. Należy jednak pamiętać, onCreateDialogotrzyma nie ViewGroupdołączyć swój zwyczaj .xml układ do . Nie ma problemu, po prostu przechodzisz nulldo inflatemetody.

Niech rozpocznie się szaleństwo.

Podczas zastępowania system onCreateDialogAndroid CAŁKOWICIE IGNORUJE kilka atrybutów węzła głównego układu .xml, który nadmuchujesz. Obejmuje to, ale prawdopodobnie nie ogranicza się do:

• background_color
• layout_gravity
• layout_width
• layout_height

Jest to prawie komiczne, ponieważ musisz ustawić layout_widthi layout_heightKAŻDEGO .xml Layout lub Android Studio uderzy cię ładną czerwoną plakietką wstydu.

Już samo słowo DialogFragment sprawia, że ​​mam ochotę zwymiotować. Mógłbym napisać powieść pełną problemów z Androidem i snafusem, ale ta jest jedną z najbardziej ukrytych.

Aby wrócić do zdrowia psychicznego, najpierw deklarujemy styl przywracania TYLKO background_colori layout_gravityoczekujemy:

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

Powyższy styl dziedziczy z motywu podstawowego dla okien dialogowych (w AppCompatmotywie w tym przykładzie).

Następnie programowo stosujemy styl, aby przywrócić wartości, które Android właśnie odrzucił, i przywrócić standardowy AlertDialogwygląd i styl:

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

Powyższy kod sprawi, że będziesz AlertDialogwyglądać AlertDialogponownie. Może to wystarczy.

Ale czekaj, jest więcej!

Jeśli szukasz, aby ustawić specyficzny layout_width lub layout_heightna Twój AlertDialogkiedy to pokazane (bardzo prawdopodobne), to wiecie co, to nie jest jeszcze gotowe!

Radość trwa, gdy zdajesz sobie sprawę, że jeśli spróbujesz ustawić konkretny layout_widthlub layout_heightw swoim nowym, wymyślnym stylu, Android całkowicie to zignoruje !:

<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>

Aby ustawić SZCZEGÓLNĄ szerokość lub wysokość okna, musisz przejść do całej metody i poradzić sobie z LayoutParams:

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

Wielu ludzi podąża za złym przykładem Androida, rzucając WindowManager.LayoutParamssię na bardziej ogólne ViewGroup.LayoutParams, tylko po to, aby odwrócić się w prawo i rzucić z ViewGroup.LayoutParamspowrotem WindowManager.LayoutParamskilka linii później. Efektywna Java, niech cholera, to niepotrzebne rzutowanie nie oferuje NIC poza tym, że kod jest jeszcze trudniejszy do rozszyfrowania.

Uwaga dodatkowa: istnieje DWADZIEŚCIA powtórzeń LayoutParamscałego zestawu Android SDK - doskonały przykład radykalnie kiepskiego projektu.

W podsumowaniu

Z DialogFragmenttego powodu onCreateDialog:

• Aby przywrócić standardowy AlertDialogwygląd i styl, utwórz styl, który ustawia background_color= transparenti layout_gravity= centeri zastosuj ten styl w programie onCreateDialog.
• Aby ustawić określony layout_widthi / lub layout_height, zrobić programowo w onResumezLayoutParams
• Aby zachować zdrowy rozsądek, staraj się nie myśleć o Android SDK.

Kiedy potrzebuję poszerzyć DialogFragment, ustawiam minWidth:

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

Nie widzę powód, aby zastąpić onResumelub onStartustawić szerokość i wysokość Windoww DialogFragment„s Dialog- te szczególne metody cyklu życia może się wielokrotnie i niepotrzebnie nazywa wykonać to zmiana rozmiaru kodu więcej niż raz z powodu wielu rzeczy, takich jak okna przełączania, w tło następnie ustawianie aplikacji na pierwszym planie i tak dalej. Konsekwencje tego powtórzenia są dość błahe, ale po co się na tym godzić?

Zamiast tego ustawienie szerokości / wysokości w ramach zastąpionej onActivityCreated()metody będzie ulepszeniem, ponieważ ta metoda jest realistycznie wywoływana tylko raz na instancję DialogFragment. Na przykład:

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

Powyżej ustawiłem szerokość match_parentniezależnie od orientacji urządzenia. Jeśli chcesz, aby okno dialogowe krajobrazu nie było tak szerokie, możesz getResources().getConfiguration().orientation == Configuration.ORIENTATION_PORTRAITwcześniej sprawdzić, czy .

Wymiar w układzie zewnętrznym nie działa w oknie dialogowym. Możesz dodać układ, w którym ustaw wymiar poniżej najbardziej zewnętrznego.

<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>

Naprawiłem to ustawiając parametry układu głównego elementu.

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

Oto sposób ustawienia szerokości / wysokości DialogFragment w xml. Po prostu zawiń swój viewHierarchy w Framelayout (każdy układ będzie działał) z przezroczystym tłem.

Przezroczyste tło wydaje się być specjalną flagą, ponieważ automatycznie wyśrodkowuje element potomny frameLayout w oknie, gdy to zrobisz. Nadal będziesz mieć pełny ekran przyciemniony za swoim fragmentem, co oznacza, że ​​Twój fragment jest aktywnym elementem.

<?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">

      .....

Oto wersja Kotlin

    override fun onResume() {
        super.onResume()

        val params:ViewGroup.LayoutParams = dialog.window.attributes
        params.width = LinearLayout.LayoutParams.MATCH_PARENT
        params.height = LinearLayout.LayoutParams.MATCH_PARENT
        dialog.window.attributes = params as android.view.WindowManager.LayoutParams
    }

Możesz użyć wartości procentowej dla szerokości.

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

W tym przykładzie użyłem Holo Theme.

Możesz poniżej kodu ustawić szerokość i wysokość układu z java.

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

Tworzę okno dialogowe za pomocą AlertDialog.Builder, więc użyłem odpowiedzi Rodrigo w OnShowListener.

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

        });

Pracując na Androidzie 6.0, napotkałem ten sam problem. AlertDialogbędzie domyślnie widthustawiać wstępnie zdefiniowany zestaw w kompozycji, niezależnie od rzeczywistego widthzestawu w katalogu głównym widoku niestandardowego Layout. Udało mi się dostać to, aby ustawić odpowiednio regulując widthz loading_message TextView. Bez dalszych badań wydaje się, że wymiarowanie rzeczywistych elementów i Layoutzawijanie wokół nich korzenia sprawia, że ​​działa zgodnie z oczekiwaniami. Poniżej znajduje się układ XML okna dialogowego ładowania, który widthprawidłowo ustawia okno dialogowe. Wykorzystanie tej biblioteki do animacji.

<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>

Łatwe i solidne:

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

W moim przypadku DialogFragmentzajęty pełny rozmiar działalności, taki jak a Fragment. DialogFragmentZostał oparty na XML-układ nie AlertDialog. Moim błędem było dodanie fragmentu okna dialogowego FragmentManagerjako zwykłego fragmentu:

fragmentManager?.beginTransaction()?.run {
    replace(R.id.container, MyDialogFragment.newInstance(), MyDialogFragment.TAG)
    addToBackStack(MyDialogFragment.TAG)
}?.commitAllowingStateLoss()

Zamiast tego potrzebuję showfragmentu dialogu:

val dialogFragment = MyDialogFragment.newInstance()
fragmentManager?.let { dialogFragment.show(it, MyDialogFragment.TAG) }

Po edycji (mam ViewPager2w układzie) fragment okna dialogowego stał się zbyt wąski:

Użyłem rozwiązania N1hk :

override fun onActivityCreated(savedInstanceState: Bundle?) {
    super.onActivityCreated(savedInstanceState)

    dialog?.window?.attributes?.width = ViewGroup.LayoutParams.MATCH_PARENT
}

Teraz ma zdefiniowaną szerokość i wysokość, a nie pełny rozmiar aktywności.

Chcę powiedzieć o onCreateViewi onCreateDialog. Jeśli masz fragment okna dialogowego oparty na układzie, możesz użyć dowolnej z tych dwóch metod.

1) Jeśli używasz onCreateView, powinieneś użyć onActivityCreateddo ustawienia szerokości.

2) Jeśli używasz onCreateDialogzamiast onCreateView, możesz ustawić tam parametry. onActivityCreatednie będą potrzebne.

override fun onCreateDialog(savedInstanceState: Bundle?): Dialog {
    super.onCreateDialog(savedInstanceState)

    val view = activity?.layoutInflater?.inflate(R.layout.your_layout, null)

    val dialogBuilder = MaterialAlertDialogBuilder(context!!).apply { // Or AlertDialog.Builder(context!!).apply
        setView(view)
        // setCancelable(false)
    }

    view.text_view.text = "Some text"

    val dialog = dialogBuilder.create()
    // You can access dialog.window here, if needed.

    return dialog
}

W moim przypadku było to spowodowane align_parentBottom="true"widokiem wnętrza a RelativeLayout. Usunięto wszystkie alignParentBottom i zmieniono wszystkie układy na pionowe LinearLayouts i problem zniknął.

Ustaw nadrzędny układ niestandardowego układu dialogowego na RelativeLayout , automatycznie uzyskaj wspólną szerokość i wysokość.

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

Jedno z wcześniejszych rozwiązań prawie zadziałało. Spróbowałem czegoś nieco innego i ostatecznie mi się to udało.

(Upewnij się, że spojrzałeś na jego rozwiązanie) To było jego rozwiązanie ... Kliknij tutaj . Zadziałało z wyjątkiem: builder.getContext (). GetTheme (). ApplyStyle (R.style.Theme_Window_NoMinWidth, true);

Zmieniłem to na

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

Ostatnia linia jest naprawdę inna.

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

To najprostsze rozwiązanie

Najlepszym rozwiązaniem, jakie znalazłem, jest zastąpienie onCreateDialog()zamiast onCreateView(). setContentView () ustawi poprawne wymiary okna przed zawyżeniem. Eliminuje potrzebę przechowywania / ustawiania wymiaru, koloru tła, stylu itp. W plikach zasobów i ustawiania ich ręcznie.

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

Dodaj do FragmentDialog:

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

To zadziała idealnie.

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

Aby uzyskać okno dialogowe obejmujące prawie cały osypisko: Najpierw zdefiniuj klasę ScreenParameter

public class ScreenParameters
{
    public static int Width;
    public static  int Height;

    public ScreenParameters()
    {
        LayoutParams l = new LayoutParams(LayoutParams.MATCH_PARENT,LayoutParams.MATCH_PARENT);
        Width= l.width;
        Height = l.height;
    }
}

Następnie musisz wywołać ScreenParamater przed metodą getDialog.getWindow (). SetLayout ()

@Override
public void onResume()
{
    super.onResume();
    ScreenParameters s = new ScreenParameters();
    getDialog().getWindow().setLayout(s.Width , s.Height);
}