¿Cómo hacer que un diálogo de alerta llene el 90% del tamaño de la pantalla?

Puedo crear y mostrar un cuadro de diálogo de alerta personalizado bien, pero aun así tengo android:layout_width/height="fill_parent"en el cuadro de diálogo XML, es tan grande como el contenido.

Lo que quiero es un diálogo que llene toda la pantalla, excepto quizás un relleno de 20 píxeles. Luego, la imagen que forma parte del cuadro de diálogo se estirará automáticamente al tamaño completo del cuadro de diálogo con fill_parent.

De acuerdo con la desarrolladora de la plataforma Android Dianne Hackborn en esta publicación del grupo de discusión, los Diálogos establecen el ancho y la altura del diseño de nivel superior de su Ventana WRAP_CONTENT. Para agrandar el cuadro de diálogo, puede establecer esos parámetros en MATCH_PARENT.

Código de demostración:

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

Tenga en cuenta que los atributos se establecen después de que se muestra el cuadro de diálogo. El sistema es quisquilloso cuando se configuran. (Supongo que el motor de diseño debe establecerlos la primera vez que se muestra el cuadro de diálogo, o algo así).

Sería mejor hacer esto extendiendo Theme.Dialog, entonces no tendría que jugar un juego de adivinanzas sobre cuándo llamar a setAttributes. (Aunque es un poco más trabajo hacer que el diálogo adopte automáticamente un tema claro u oscuro apropiado, o el tema Honeycomb Holo. Eso se puede hacer de acuerdo con http://developer.android.com/guide/topics/ui/themes. html # SelectATheme )

Intente ajustar su diseño de diálogo personalizado en RelativeLayoutlugar de LinearLayout. Eso funcionó para mí.

Especificar FILL_PARENT en la ventana de diálogo, como sugirieron otros, no funcionó para mí (en Android 4.0.4), ya que simplemente extendió el fondo de diálogo negro para llenar toda la pantalla.

Lo que funciona bien es usar el valor de visualización mínimo, pero especificarlo dentro del código, de modo que el diálogo tome el 90% de la pantalla.

Entonces:

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

En general, solo ajustar el ancho debería ser suficiente en la mayoría de los casos.

Establecer android:minWidthy android:minHeighten su vista personalizada xml. Estos pueden forzar la alerta no solo a ajustar el tamaño del contenido. Usar una vista como esta debería hacerlo:

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

Aún más simple, solo haz esto:

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

Todas las otras respuestas aquí tienen sentido, pero no cumplieron con lo que Fabian necesita. Aquí hay una solución mía. Puede que no sea la solución perfecta, pero funciona para mí. Muestra un cuadro de diálogo que está en pantalla completa, pero puede especificar un relleno en la parte superior, inferior, izquierda o derecha.

Primero ponga esto en su res / values ​​/ 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>

Como puede ver, tengo android: paddingTop = 20dp es básicamente lo que necesita. El android: windowBackground = @ color / Black0Percent es solo un código de color declarado en mi color.xml

res / values ​​/ color.xml

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

Ese código de color solo sirve como un maniquí para reemplazar el fondo de la ventana predeterminada del cuadro de diálogo con un color de transparencia del 0%.

A continuación, cree el diseño de diálogo personalizado 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>

Finalmente, aquí está nuestro diálogo que establece una vista personalizada que utiliza nuestro 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();

Conclusión: intenté anular el tema del diálogo en styles.xml llamado CustomDialog. Anula el diseño de la ventana de diálogo y me da la oportunidad de establecer un relleno y cambiar la opacidad del fondo. Puede que no sea la solución perfecta, pero espero que te ayude ... :)

Puede usar el porcentaje para (SOLO) ancho de diálogo de ventanas.

Mira este ejemplo de Holo Theme:

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

Todo lo que necesita hacer es extender este tema y cambiar los valores de "Mayor" y "Menor" al 90% en lugar del 65%.

Saludos.

Lo siguiente funcionó bien para mí:

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

(nota: windowMinWidthMajor / Minor, como se sugirió en las respuestas anteriores, no funcionó. Mis cuadros de diálogo cambiaron de tamaño dependiendo del contenido)

y entonces:

AlertDialog.Builder builder = new AlertDialog.Builder(getActivity(), R.style.MyAlertDialogTheme);

Solución con cálculo real del 90%:

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

donde getScreenWidth(Activity activity)se define lo siguiente (mejor puesto en una clase Utils):

public static int getScreenWidth(Activity activity) {
   Point size = new Point();
   activity.getWindowManager().getDefaultDisplay().getSize(size);
   return size.x;
}

Obtenga el ancho del dispositivo:

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

luego use eso para hacer el diálogo del 90% del dispositivo,

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

Bueno, debe configurar la altura y el ancho de su cuadro de diálogo antes de mostrar esto (dialog.show ())

entonces, haz algo como esto:

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

//then

dialog.show()

Con mucho, la forma más simple que se me ocurre:

Si su diálogo está hecho de un diseño lineal lineal, simplemente agregue una vista ficticia de "relleno de altura", que ocupará toda la altura de la pantalla.

Por ejemplo -

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

Observe los android:weightSum="1"atributos en los atributos LinearLayout y android:layout_weight="1"en los atributos de la vista ficticia.

Bueno, debe configurar la altura y el ancho de su cuadro de diálogo antes de mostrar esto (dialog.show ())

entonces, haz algo como esto:

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

//then

dialog.show()

Obteniendo este código, lo hice algunos cambios:

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

sin embargo, el tamaño del diálogo puede cambiar cuando el dispositivo cambia su posición. Tal vez necesite manejar por su cuenta cuando las métricas cambien. PD: peekDecorView, implica que el diseño de la actividad se inicializa correctamente; de ​​lo contrario, puede usar

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

para obtener el tamaño de la pantalla

Después de inicializar su objeto de diálogo y establecer la vista de contenido. Haz esto y disfruta.

(en el caso, estoy configurando 90% de ancho y 70% de alto porque el ancho de 90% estará sobre la barra de herramientas)

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

Mi respuesta se basa en koma, pero no requiere anular onStart, sino solo onCreateView, que casi siempre se anula de manera predeterminada cuando se crean nuevos fragmentos.

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

Lo he probado en Android 5.0.1.

Aquí está mi variante para el ancho del cuadro de diálogo personalizado:

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

Por lo tanto, dependiendo de la orientación del dispositivo ( ThemeHelper.isPortrait(mContext)), el ancho del diálogo será del 95% (para el modo vertical) o del 65% (para el horizontal). Es un poco más de lo que preguntó el autor, pero podría ser útil para alguien.

Debe crear una clase que se extienda desde Dialog y poner este código en su onCreate(Bundle savedInstanceState) método.

Para la altura del diálogo, el código debe ser similar a este.

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

Por encima de muchas de las respuestas son buenas, pero ninguna funcionó completamente para mí. Así que combiné la respuesta de @nmr y obtuve esta.

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

Si está utilizando el diseño de restricción , puede configurar cualquier vista dentro de él, para llenar un porcentaje de la pantalla con:

layout_constraintWidth_percent = "0.8"

Entonces, por ejemplo, si tiene un ScrollView dentro del cuadro de diálogo y desea establecerlo en un porcentaje de la altura de la pantalla. Sería así:

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

Espero que ayude a alguien !!

Solo dale al AlertDialog este tema

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

Debe usar un estilo @ style.xml como CustomDialog para mostrar el cuadro de diálogo personalizable.

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

y usa este estilo en Activity.java como este

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

y su custom_dialog.xml debería estar dentro de su directorio de diseño

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

Aquí hay una respuesta corta que funcionó para mí (Probado en API 8 y 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);

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

        }
    });