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

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.

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 )

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

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.

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>

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

dialog.getWindow().setLayout(LayoutParams.FILL_PARENT, LayoutParams.FILL_PARENT);

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

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.

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

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

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

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

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

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

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

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.

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.

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

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

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

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!

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>

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

dialog.getWindow().setLayout(WindowManager.LayoutParams.MATCH_PARENT,WindowManager.LayoutParams.WRAP_CONTENT);

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>

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

        }
    });