Jak sprawić, aby okno dialogowe z alertem wypełniało 90% wielkości ekranu?

304

Mogę stworzyć i wyświetlić niestandardowe okno dialogowe alertu, ale mimo to mam android:layout_width/height="fill_parent"w oknie dialogowym xml, jest on tak duży jak zawartość.

Chcę, aby okno dialogowe wypełniało cały ekran, z wyjątkiem może wypełnienia 20 pikseli. Następnie obraz będący częścią okna dialogowego automatycznie rozciągałby się do pełnego rozmiaru okna dialogowego za pomocą fill_parent.

fabiański
źródło

Odpowiedzi:

355

Według twórcy platformy Android, Dianne Hackborn w tym poście w grupie dyskusyjnej, Dialogi ustawiły szerokość i wysokość układu najwyższego poziomu okna na WRAP_CONTENT. Aby powiększyć okno dialogowe, możesz ustawić te parametry naMATCH_PARENT .

Kod demonstracyjny:

    AlertDialog.Builder adb = new AlertDialog.Builder(this);
    Dialog d = adb.setView(new View(this)).create();
    // (That new View is just there to have something inside the dialog that can grow big enough to cover the whole screen.)

    WindowManager.LayoutParams lp = new WindowManager.LayoutParams();
    lp.copyFrom(d.getWindow().getAttributes());
    lp.width = WindowManager.LayoutParams.MATCH_PARENT;
    lp.height = WindowManager.LayoutParams.MATCH_PARENT;
    d.show();
    d.getWindow().setAttributes(lp);

Zauważ, że atrybuty są ustawiane po wyświetleniu okna dialogowego. System jest drobiazgowy, kiedy jest ustawiony. (Wydaje mi się, że silnik układu musi ustawić je przy pierwszym wyświetleniu okna dialogowego lub coś w tym rodzaju).

Lepiej byłoby to zrobić, rozszerzając Theme.Dialog, wtedy nie musiałbyś grać w zgadywanie, kiedy wywołać setAttributes. (Chociaż nieco więcej pracy wymaga, aby okno dialogowe automatycznie przyjęło odpowiedni jasny lub ciemny motyw lub motyw Honeycomb Holo. Można to zrobić zgodnie z http://developer.android.com/guide/topics/ui/themes. HTML # SelectATheme )

nmr
źródło
5
Czy nie rozumiem odpowiedzi, czy to nie działa dla mnie.
David Morales,
4
Nie wydaje się prawdą, że okna dialogowe są szeroko zawijane. Sprawy stają się węższe i odcięte. Wygląda na to, że okno dialogowe jest ustawione na pewną maksymalną z góry określoną szerokość.
Peter Ajtai,
21
Nie rozumiem, jak to odpowiada na pytanie? Czy kod sugerowany przez @nmr powoduje, że okno dialogowe stanowi 90% ekranu? Bo nie widzę tego. Okno dialogowe jest ustawione na fill_width, więc to 100%, a nie 90%, prawda?
Ted
4
@Ted, motyw używany przez AlertDialog ma margines. Tak więc wynik nie dociera do krawędzi ekranu, wypełnia około 90%. (To zdecydowanie nie dokładnie 90%, tylko estetyczne przybliżenie 90%)
nmr
8
Wystarczy wywołać funkcję d.getWindow (). GetAttributes (). Width = WindowManager.LayoutParams.FILL_PARENT; przed wywołaniem show () załatwi sprawę. Ponadto miałem pewne problemy z daną metodą, ponieważ tło okna dialogowego stawało się nieprzejrzyste. Gdy tylko usunięto copyFrom (() problem sam się rozwiązał
Alexey
182

Spróbuj owinąć niestandardowy układ okna dialogowego RelativeLayoutzamiast LinearLayout. To działało dla mnie.

cvarsendan
źródło
2
ma to również dla mnie. Czy ktoś może wyjaśnić powód !!
Rozina
Czy w ten sposób RelativeLayout ma działać, czy szczęśliwy wypadek, który może odejść?
Yetti99
9
Jest rok 2019 i nadal działa. Twoje zdrowie! Rzeczywiście powinna być zaakceptowana odpowiedź.
TaylanUB
@ cvarsendan czy możesz wyjaśnić odpowiedź? To działało dla mnie. Dziękuję Ci!
Jaco
OMG, My RecyclerView nigdy nie wyświetla pełnej wysokości lub zawsze ma wysokość 0, a dzięki temu działa doskonale po dniu wypróbowania wielu rozwiązań. Dlaczego RelativeLayout, a inne?
leegor
85

Określenie FILL_PARENT w oknie dialogowym, jak sugerowali inni, nie działało dla mnie (na Androidzie 4.0.4), ponieważ po prostu rozciągnęło czarne tło okna dialogowego, aby wypełnić cały ekran.

To, co działa dobrze, to użycie minimalnej wartości wyświetlania, ale określenie jej w kodzie, dzięki czemu okno dialogowe zajmuje 90% ekranu.

Więc:

Activity activity = ...;
AlertDialog dialog = ...;

// retrieve display dimensions
Rect displayRectangle = new Rect();
Window window = activity.getWindow();
window.getDecorView().getWindowVisibleDisplayFrame(displayRectangle);

// inflate and adjust layout
LayoutInflater inflater = (LayoutInflater)activity.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
View layout = inflater.inflate(R.layout.your_dialog_layout, null);
layout.setMinimumWidth((int)(displayRectangle.width() * 0.9f));
layout.setMinimumHeight((int)(displayRectangle.height() * 0.9f));

dialog.setView(layout);

Ogólnie rzecz biorąc, w większości przypadków wystarczające jest jedynie dostosowanie szerokości.

koma
źródło
Nie wydaje się, aby działało to całkowicie w wersji 4.0 i nowszych. Nie wypełnia 90% ekranu. Masz pomysł, dlaczego? Robię to na Motoroli Xoom z wersją 4.0
Ryan Gray
@RyanGray Działa dla mnie na Samsung Nexus S ze zaktualizowanym systemem operacyjnym. Bez dodatkowych informacji niestety nie mogę ci pomóc.
koma
83

Ustaw android:minWidthi android:minHeightw swoim niestandardowym widoku xml. Mogą one zmusić alert do nie tylko zawijania rozmiaru zawartości. Korzystając z takiego widoku, należy to zrobić:

<LinearLayout
  xmlns:android="http://schemas.android.com/apk/res/android"
  android:layout_width="fill_parent"
  android:layout_height="fill_parent"
  android:minWidth="300dp" 
  android:minHeight="400dp">
  <ImageView
   android:layout_width="fill_parent"
   android:layout_height="fill_parent"
   android:background="@drawable/icon"/>
</LinearLayout>
jqpubliq
źródło
3
Tak, dzięki temu mogę ustawić konkretny rozmiar, ale chcę, aby był ekranowany minus dopełnienie np. 20 pikseli. Lub szerokość = 90% szerokości ekranu.
Fabian
4
Piksele niezależne od gęstości są zawsze skalowane, tak aby każdy ekran miał 320 x 480 pikseli, więc widok 300 x 460 pikseli byłby wypełnieniem 20dp we wszystkich przypadkach. Alternatywnie możesz znaleźć rozmiar ekranu w następujący sposób: Display display = ((WindowManager) getSystemService (Context.WINDOW_SERVICE)). GetDefaultDisplay (); int width = display.getWidth (); i odpowiednio ustaw maxWidth i maxHeight.
jqpubliq
5
Hmm z odbarwienia Rozumiem pojęcie dp. Ale co, jeśli proporcje ekranu wynoszą 16: 9 lub 4: 3? Czy DP będzie rozciągany nierównomiernie?
Fabian
2
Nie, rozdzielczość dp będzie wynosić 320x480, jeśli proporcje ekranu wynoszą 2: 3, więc ta metoda nie będzie działać.
mhsmith,
21
co, dlaczego ta odpowiedź jest oceniana tak wiele razy? jest to okropne rozwiązanie, ponieważ nie ma żadnego wpływu na rozmiar urządzenia, z którego korzysta użytkownik.
Jin
70

Jeszcze prostsze po prostu zrób to:

int width = (int)(getResources().getDisplayMetrics().widthPixels*0.90);
int height = (int)(getResources().getDisplayMetrics().heightPixels*0.90);

alertDialog.getWindow().setLayout(width, height);
FOMDeveloper
źródło
drobna uwaga: getResources () jest dostępny w kontekście działania.
nat101
Ta odpowiedź była bardzo pomocna w scenariuszu próby odtworzenia okna dialogowego onCreatepo rotacji urządzenia. W tym przypadku nie możemy polegać na szerokości / wysokości czegokolwiek w układzie, ponieważ nie został on jeszcze utworzony; ale fizyczna szerokość / wysokość urządzenia są nadal dostępne.
Tim Biegeleisen
4
Jeśli chcesz zmienić tylko jeden wymiar, podaj ViewGroup.LayoutParams.WRAP_CONTENTjako jeden z parametrów
Vadim Kotov
53
dialog.getWindow().setLayout(LayoutParams.FILL_PARENT, LayoutParams.FILL_PARENT);
Elvis
źródło
1
To działało dla mnie i było łatwe do przetłumaczenia na MonoDroid, który działał tak (gdzie d jest nowym oknem dialogowym): d.Window.SetLayout (WindowManagerLayoutParams.FillParent, WindowManagerLayoutParams.FillParent);
TheJerm
9
Ale 90% to nie to samo co 100%. FILL_PARENT wskazuje na wypełnienie całej szerokości, 100%, a nie 90%. Dobrze?
Ted
@Ted Masz rację. Możesz zastąpić FILL_PARENTszerokość obliczoną jako 90% szerokości bieżącego wyświetlacza. Ale podoba mi się odpowiedź, ponieważ jest łatwiejsza niż inne.
HRJ,
26

Wszystkie pozostałe odpowiedzi tutaj mają sens, ale nie spełniały wymagań Fabiana. Oto moje rozwiązanie. To może nie być idealne rozwiązanie, ale działa dla mnie. Wyświetla okno dialogowe na pełnym ekranie, ale możesz określić wypełnienie u góry, u dołu, z lewej lub z prawej strony.

Najpierw umieść to w swoim res / wartości / styles.xml:

<style name="CustomDialog" parent="@android:style/Theme.Dialog">
    <item name="android:windowIsTranslucent">true</item>
    <item name="android:windowBackground">@color/Black0Percent</item>
    <item name="android:paddingTop">20dp</item>
    <item name="android:windowContentOverlay">@null</item>
    <item name="android:windowNoTitle">true</item>
    <item name="android:backgroundDimEnabled">false</item>
    <item name="android:windowIsFloating">false</item>
</style>

Jak widać mam tam Androida: paddingTop = 20dp jest w zasadzie tym, czego potrzebujesz. Android: windowBackground = @ kolor / Black0Percent jest tylko kod koloru ogłoszony na moim color.xml

res / wartości / color.xml

<?xml version="1.0" encoding="utf-8"?>
<resources>
<color name="Black0Percent">#00000000</color>
</resources>

Ten kod koloru służy jedynie jako manekin do zamiany domyślnego tła okna okna dialogowego na kolor przezroczystości 0%.

Następnie skompiluj niestandardowy układ okna dialogowego res / layout / dialog.xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:id="@+id/dialoglayout"
    android:layout_width="match_parent"
    android:background="@drawable/DesiredImageBackground"
    android:layout_height="match_parent"
    android:orientation="vertical" >

    <EditText
        android:id="@+id/edittext1"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:singleLine="true"
        android:textSize="18dp" />

    <Button
        android:id="@+id/button1"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="Dummy Button"
        android:textSize="18dp" />

</LinearLayout>

Wreszcie jest nasze okno dialogowe, które ustawia niestandardowy widok, który korzysta z naszego pliku dialog.xml:

Dialog customDialog;
LayoutInflater inflater = (LayoutInflater) getLayoutInflater();
View customView = inflater.inflate(R.layout.dialog, null);
// Build the dialog
customDialog = new Dialog(this, R.style.CustomDialog);
customDialog.setContentView(customView);
customDialog.show();

Wniosek: Próbowałem zastąpić motyw okna dialogowego w pliku styles.xml o nazwie CustomDialog. Zastępuje układ okna dialogowego i daje mi możliwość ustawienia wypełnienia i zmiany krycia tła. To może nie być idealne rozwiązanie, ale mam nadzieję, że ci to pomoże :)

icaneatclouds
źródło
działa na jellybean na razie nie byłem w stanie przetestować innych żarówek
Nasz Njoka Sr.
Wydaje się najczystszym i najbardziej eleganckim rozwiązaniem. Działa na Kitkat 4.4 i 4.3.
David
Mam niestandardowe okno dialogowe i NIC nie działało, dopóki tego nie zobaczę, magia, CAŁA MAGIA w niestandardowym oknie dialogowym (które się rozszerza DialogFragment) przychodzi, kiedy to robisz: Dialog customDialog = new Dialog(context, STYLE);dzięki, NAPRAWDĘ, dziękuję.
Sierisimo,
Dobrze wiedzieć, że to pomaga :)
icaneatclouds
To działa jak urok okna dialogowego! (możesz także zdefiniować Black60Percent, aby oryginalne okno było wyszarzone) Niefortunnym efektem ubocznym jest to, że wszystkie moje widoki w oknie dialogowym odziedziczyły wypełnienia, które ustawiłem dla okna dialogowego ...
runholen
25

Możesz użyć wartości procentowej dla szerokości okna dialogowego (JUST).

Spójrz na ten przykład z motywu Holo:

<style name="Theme.Holo.Dialog.NoActionBar.MinWidth">
    <item name="android:windowMinWidthMajor">@android:dimen/dialog_min_width_major</item>
    <item name="android:windowMinWidthMinor">@android:dimen/dialog_min_width_minor</item>
</style>

 <!-- The platform's desired minimum size for a dialog's width when it
     is along the major axis (that is the screen is landscape).  This may
     be either a fraction or a dimension. -->
<item type="dimen" name="dialog_min_width_major">65%</item>

Wszystko, co musisz zrobić, to rozszerzyć ten motyw i zmienić wartości „Major” i „Minor” do 90% zamiast 65%.

Pozdrowienia.

Joao Gavazzi
źródło
1
Aby użyć tego z oknem dialogowym, po prostu przekaż swój własny styl w konstruktorze konstruktora okien dialogowych :)
s
22

Dla mnie dobrze działały:

    <style name="MyAlertDialogTheme" parent="Base.Theme.AppCompat.Light.Dialog.Alert">
        <item name="windowFixedWidthMajor">90%</item>
        <item name="windowFixedWidthMinor">90%</item>
    </style>

(uwaga: windowMinWidthMajor / Minor, jak sugerowano w poprzednich odpowiedziach, nie pomogło. Moje okna dialogowe ciągle zmieniały rozmiary w zależności od zawartości)

i wtedy:

AlertDialog.Builder builder = new AlertDialog.Builder(getActivity(), R.style.MyAlertDialogTheme);
Deliriom
źródło
3
Najlepsza jak dotąd odpowiedź. Działa dla mnie idealnie!
Pawan
Zastanawiam się: jak mogę uzyskać wartość takich specjalnych wymiarów, które są ustawione procentowo, za pomocą kodu?
programista Androida
18

Rozwiązanie z faktycznymi obliczeniami 90%:

@Override public void onStart() {
   Dialog dialog = getDialog();
   if (dialog != null) {
     dialog.getWindow()
        .setLayout((int) (getScreenWidth(getActivity()) * .9), ViewGroup.LayoutParams.MATCH_PARENT);
   }
}

gdzie getScreenWidth(Activity activity)zdefiniowano następujące (najlepiej umieścić w klasie Utils):

public static int getScreenWidth(Activity activity) {
   Point size = new Point();
   activity.getWindowManager().getDefaultDisplay().getSize(size);
   return size.x;
}
Mehmet K.
źródło
działa jak urok dla kompatybilności aplikacji, która powinna działać jak okno dialogowe
Dostaję z tego powodu indeks tablicy :(
Dr. aNdRO
@ Dr.aNdRO jak? Która linia? Jesteś pewien, że to ten fragment kodu, a nie smt?
Mehmet K,
.setLayout () Przechodzę do tej linii, kiedy zmieniam ją na ZAWARTOŚĆ
OPAKOWANIA,
10

Uzyskaj szerokość urządzenia:

public static int getWidth(Context context) {
    DisplayMetrics displayMetrics = new DisplayMetrics();
    WindowManager windowmanager = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
    windowmanager.getDefaultDisplay().getMetrics(displayMetrics);
    return displayMetrics.widthPixels;
}

następnie użyj go do utworzenia 90% okna dialogowego,

Dialog filterDialog = new Dialog(context, R.style.searchsdk_FilterDialog);

filterDialog.setContentView(R.layout.searchsdk_filter_popup);
initFilterDialog(filterDialog);
filterDialog.setCancelable(true);
filterDialog.getWindow().setLayout(((getWidth(context) / 100) * 90), LinearLayout.LayoutParams.MATCH_PARENT);
filterDialog.getWindow().setGravity(Gravity.END);
filterDialog.show();
Gopinath
źródło
8

Cóż, musisz ustawić wysokość i szerokość okna dialogowego, aby to pokazać (dialog.show ())

więc zrób coś takiego:

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

//then

dialog.show()
shontauro
źródło
Nie ustawia dla mnie wymiarów. API> = 21.
Odys
7

Zdecydowanie najprostszy sposób, jaki mogę wymyślić -

Jeśli twoje okno dialogowe składa się z pionowego układu liniowego, po prostu dodaj widok manekina „wypełniający wysokość”, który zajmie całą wysokość ekranu.

Na przykład -

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
          android:orientation="vertical"
          android:layout_width="match_parent"
          android:layout_height="match_parent"
          android:weightSum="1">

    <EditText
       android:layout_width="match_parent"
       android:layout_height="wrap_content"
       android:id="@+id/editSearch" />

    <ListView
       android:layout_width="match_parent"
       android:layout_height="match_parent"
       android:id="@+id/listView"/>


   <!-- this is a dummy view that will make sure the dialog is highest -->
   <View
       android:layout_width="match_parent"
       android:layout_height="match_parent"
       android:layout_weight="1"/>

</LinearLayout>

Zwróć android:weightSum="1"uwagę na atrybuty LinearLayout i atrapy Atrybutów android:layout_weight="1"widoku

Ron Tesler
źródło
Miły! Dzięki temu mój widok nie zaczyna się od bardzo krótkiego i nie rozwija się do pełnej wysokości po zakończeniu onPageFinished. Sława!
Nancy
6

Cóż, musisz ustawić wysokość i szerokość okna dialogowego, aby to pokazać (dialog.show ())

więc zrób coś takiego:

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

//then

dialog.show()

Otrzymując ten kod, wprowadziłem kilka zmian:

dialog.getWindow().setLayout((int)(MapGeaGtaxiActivity.this.getWindow().peekDecorView().getWidth()*0.9),(int) (MapGeaGtaxiActivity.this.getWindow().peekDecorView().getHeight()*0.9));

jednak rozmiar okna dialogowego może ulec zmianie, gdy urządzenie zmieni swoją pozycję. Być może musisz poradzić sobie sam, gdy zmienią się dane. PD: peekDecorView, oznacza, że ​​układ w działaniu jest poprawnie zainicjowany, w przeciwnym razie możesz go użyć

DisplayMetrics metrics = new DisplayMetrics();
getWindowManager().getDefaultDisplay().getMetrics(metrics);
int height = metrics.heightPixels;
int wwidth = metrics.widthPixels;

w celu uzyskania rozmiaru ekranu

Juan Otero
źródło
6

Po zainicjowaniu obiektu okna dialogowego i ustawieniu widoku zawartości. Zrób to i ciesz się.

(w przypadku, gdy ustawiam 90% na szerokość i 70% na wysokość, ponieważ szerokość 90% będzie ponad paskiem narzędzi)

DisplayMetrics displaymetrics = new DisplayMetrics();
getActivity().getWindowManager().getDefaultDisplay().getMetrics(displaymetrics);
int width = (int) ((int)displaymetrics.widthPixels * 0.9);
int height = (int) ((int)displaymetrics.heightPixels * 0.7);
d.getWindow().setLayout(width,height);
d.show();
Guilherme Pereira
źródło
4

Moja odpowiedź oparta jest na komie, ale nie wymaga zastąpienia onStart, ale tylko onCreateView, który prawie zawsze jest zastępowany domyślnie podczas tworzenia nowych fragmentów.

@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container,
                         Bundle savedInstanceState) {
    View v = inflater.inflate(R.layout.your_fragment_layout, container);

    Rect displayRectangle = new Rect();
    Window window = getDialog().getWindow();
    window.getDecorView().getWindowVisibleDisplayFrame(displayRectangle);

    v.setMinimumWidth((int)(displayRectangle.width() * 0.9f));
    v.setMinimumHeight((int)(displayRectangle.height() * 0.9f));

    return v;
}

Przetestowałem to na Androidzie 5.0.1.

Kresimir Plese
źródło
3

Oto mój wariant niestandardowej szerokości okna dialogowego:

DisplayMetrics displaymetrics = new DisplayMetrics();
mActivity.getWindowManager().getDefaultDisplay().getMetrics(displaymetrics);
int width = (int) (displaymetrics.widthPixels * (ThemeHelper.isPortrait(mContext) ? 0.95 : 0.65));

WindowManager.LayoutParams params = getWindow().getAttributes();
params.width = width;
getWindow().setAttributes(params);

W zależności od orientacji urządzenia (ThemeHelper.isPortrait(mContext) ) szerokość okna dialogowego będzie wynosić 95% (dla trybu pionowego) lub 65% (dla poziomego). To trochę więcej, niż autor poprosił, ale może być przydatne dla kogoś.

Musisz utworzyć klasę wykraczającą poza Dialog i umieścić ten kod w swojej onCreate(Bundle savedInstanceState)metodzie.

Dla wysokości okna dialogowego kod powinien być podobny do tego.

Klany
źródło
Co to jest ThemeHelper? Nie mam tej klasy dostępnej w moim projekcie.
Nemi
ThemeHelperjest tylko klasą pomocniczą dla moich potrzeb. Ta metoda isPortrait(Context)zwraca, czy orientacja ekranu urządzenia jest pionowa czy pozioma.
Klany,
będzie to miało problem, jeśli po załadowaniu okna dialogowego, a następnie zmianie orientacji, ustawienie początkowe pozostanie w onCreate
iBabur,
3
public static WindowManager.LayoutParams setDialogLayoutParams(Activity activity, Dialog dialog)
    {
        try 
        {
            Display display = activity.getWindowManager().getDefaultDisplay();
            Point screenSize = new Point();
            display.getSize(screenSize);
            int width = screenSize.x;

            WindowManager.LayoutParams layoutParams = new WindowManager.LayoutParams();
            layoutParams.copyFrom(dialog.getWindow().getAttributes());
            layoutParams.width = (int) (width - (width * 0.07) ); 
            layoutParams.height = WindowManager.LayoutParams.WRAP_CONTENT;
            return layoutParams;
        } 
        catch (Exception e)
        {
            e.printStackTrace();
            return null;
        }
    }
Krunal Shah
źródło
3

Powyżej wielu odpowiedzi są dobre, ale żadna z nich nie zadziałała dla mnie w pełni. Więc połączyłem odpowiedź z @nmr i otrzymałem ten.

final Dialog d = new Dialog(getActivity());
        //  d.getWindow().setBackgroundDrawable(R.color.action_bar_bg);
        d.requestWindowFeature(Window.FEATURE_NO_TITLE);
        d.setContentView(R.layout.dialog_box_shipment_detail);

        WindowManager wm = (WindowManager) getActivity().getSystemService(Context.WINDOW_SERVICE); // for activity use context instead of getActivity()
        Display display = wm.getDefaultDisplay(); // getting the screen size of device
        Point size = new Point();
        display.getSize(size);
        int width = size.x - 20;  // Set your heights
        int height = size.y - 80; // set your widths

        WindowManager.LayoutParams lp = new WindowManager.LayoutParams();
        lp.copyFrom(d.getWindow().getAttributes());

        lp.width = width;
        lp.height = height;

        d.getWindow().setAttributes(lp);
        d.show();
anand
źródło
3
    ...
    AlertDialog.Builder builder = new AlertDialog.Builder(getActivity());
    Dialog d = builder.create(); //create Dialog
    d.show(); //first show

    DisplayMetrics metrics = new DisplayMetrics(); //get metrics of screen
    getActivity().getWindowManager().getDefaultDisplay().getMetrics(metrics);
    int height = (int) (metrics.heightPixels*0.9); //set height to 90% of total
    int width = (int) (metrics.widthPixels*0.9); //set width to 90% of total

    d.getWindow().setLayout(width, height); //set layout
Guihgo
źródło
3
wyświetlanie okna dialogowego przed ustawieniem układu działa dla mnie.
Angel Koh
2

Jeśli używasz układu ograniczeń , możesz ustawić w nim dowolny widok, aby wypełnić procent ekranu:

layout_constraintWidth_percent = "0.8"

Na przykład, jeśli masz ScrollView w oknie dialogowym i chcesz ustawić go na procent wysokości ekranu. Byłoby tak:

<ScrollView
            android:id="@+id/scrollView"
            android:layout_width="match_parent"
            android:layout_height="0dp"
            app:layout_constraintHeight_percent="0.8">

Mam nadzieję, że to komuś pomaga!

Lucas
źródło
2

Daj AlertDialog ten motyw

<style name="DialogTheme" parent="Theme.MaterialComponents.Light.Dialog.MinWidth">
    <item name="colorPrimary">@color/colorPrimary</item>
    <item name="android:windowMinWidthMajor">90%</item>
    <item name="android:windowMinWidthMinor">90%</item>
</style>
karimaounn
źródło
1

Oto krótka odpowiedź, która zadziałała dla mnie (Testowane na API 8 i API 19).

Dialog mDialog;
View   mDialogView;
...
// Get height
int height = mDialog.getWindow()
.getWindowManager().getDefaultDisplay()
.getHeight();

// Set your desired padding (here 90%)
int padding = height - (int)(height*0.9f);

// Apply it to the Dialog
mDialogView.setPadding(
// padding left
0,
// padding top (90%)
padding, 
// padding right
0, 
// padding bottom (90%)
padding);
Tanaza
źródło
1
dialog.getWindow().setLayout(WindowManager.LayoutParams.MATCH_PARENT,WindowManager.LayoutParams.WRAP_CONTENT);
Sai Gopi N.
źródło
1

musisz użyć stylu @ style.xml, takiego jak CustomDialog, aby wyświetlić okno dialogowe, które można dostosować.

<style name="CustomDialog" parent="@android:style/Theme.DeviceDefault.Light.Dialog">
        <item name="android:windowIsTranslucent">true</item>
        <item name="android:windowBackground">@color/colorWhite</item>
        <item name="android:editTextColor">@color/colorBlack</item>
        <item name="android:windowContentOverlay">@null</item>
        <item name="android:windowNoTitle">true</item>
        <item name="android:backgroundDimEnabled">true</item>
        <item name="android:windowIsFloating">true</item>
        <item name="android:windowSoftInputMode">stateUnspecified|adjustPan</item>
    </style>

i użyj tego stylu w Activity.java w ten sposób

Dialog dialog= new Dialog(Activity.this, R.style.CustomDialog);
        dialog.requestWindowFeature(Window.FEATURE_NO_TITLE);
        dialog.setContentView(R.layout.custom_dialog);

i twój custom_dialog.xml powinien znajdować się w katalogu układu

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:paddingLeft="10dp"
    android:paddingRight="10dp">

    <TextView
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text=""
        android:textSize="20dp"
        android:id="@+id/tittle_text_view"
        android:textColor="@color/colorBlack"
        android:layout_marginTop="20dp"
        android:layout_marginLeft="10dp"/>

    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:orientation="horizontal"
        android:layout_marginLeft="20dp"
        android:layout_marginBottom="10dp"
        android:layout_marginTop="20dp"
        android:layout_marginRight="20dp">

        <EditText
            android:id="@+id/edit_text_first"
            android:layout_width="50dp"
            android:layout_height="match_parent"
            android:hint="0"
            android:inputType="number" />

        <TextView
            android:id="@+id/text_view_first"
            android:layout_width="wrap_content"
            android:layout_height="match_parent"
            android:layout_marginLeft="5dp"
            android:gravity="center"/>

        <EditText
            android:id="@+id/edit_text_second"
            android:layout_width="50dp"
            android:layout_height="match_parent"
            android:hint="0"
            android:layout_marginLeft="5dp"
            android:inputType="number" />

        <TextView
            android:id="@+id/text_view_second"
            android:layout_width="wrap_content"
            android:layout_height="match_parent"
            android:layout_marginLeft="5dp"
            android:gravity="center"/>

    </LinearLayout>

</LinearLayout>
Nuwan Withanage
źródło
0
    final AlertDialog alertDialog;

    LayoutInflater li = LayoutInflater.from(mActivity);
    final View promptsView = li.inflate(R.layout.layout_dialog_select_time, null);

    RecyclerView recyclerViewTime;
    RippleButton buttonDone;

    AlertDialog.Builder alertDialogBuilder = new AlertDialog.Builder(mActivity);
    alertDialogBuilder.setView(promptsView);

    // create alert dialog
    alertDialog = alertDialogBuilder.create();

    /**
     * setting up window design
     */
    alertDialog.requestWindowFeature(Window.FEATURE_NO_TITLE);


    alertDialog.show();

    DisplayMetrics metrics = new DisplayMetrics(); //get metrics of screen
    mActivity.getWindowManager().getDefaultDisplay().getMetrics(metrics);
    int height = (int) (metrics.heightPixels * 0.9); //set height to 90% of total
    int width = (int) (metrics.widthPixels * 0.9); //set width to 90% of total

    alertDialog.getWindow().setLayout(width, height); //set layout
    recyclerViewTime = promptsView.findViewById(R.id.recyclerViewTime);


    DialogSelectTimeAdapter dialogSelectTimeAdapter = new DialogSelectTimeAdapter(this);
    RecyclerView.LayoutManager linearLayoutManager = new LinearLayoutManager(this);
    recyclerViewTime.setLayoutManager(linearLayoutManager);
    recyclerViewTime.setAdapter(dialogSelectTimeAdapter);

    buttonDone = promptsView.findViewById(R.id.buttonDone);
    buttonDone.setOnClickListener(new View.OnClickListener() {
        @Override
        public void onClick(View view) {

            alertDialog.dismiss();

        }
    });
Neelu Agrawal
źródło
niestandardowe okno dialogowe z niestandardową wysokością okna
Neelu Agrawal