Comment faire pour qu'une boîte de dialogue d'alerte remplisse 90% de la taille de l'écran?

Je peux créer et afficher une boîte de dialogue d'alerte personnalisée très bien, mais même si j'ai android:layout_width/height="fill_parent"dans la boîte de dialogue xml, elle est aussi grande que le contenu.

Ce que je veux, c'est une boîte de dialogue qui remplisse tout l'écran, sauf peut-être un remplissage de 20 pixels. Ensuite, l'image qui fait partie de la boîte de dialogue s'étendrait automatiquement à la taille de la boîte de dialogue complète avec fill_parent.

Selon le développeur de la plateforme Android Dianne Hackborn dans ce post de groupe de discussion, Dialogs définit la largeur et la hauteur de la disposition de haut niveau de leur fenêtre sur WRAP_CONTENT. Pour agrandir la boîte de dialogue, vous pouvez définir ces paramètres surMATCH_PARENT .

Code de démonstration:

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

Notez que les attributs sont définis une fois la boîte de dialogue affichée. Le système est capricieux quand ils sont définis. (Je suppose que le moteur de disposition doit les définir la première fois que la boîte de dialogue est affichée, ou quelque chose du genre.)

Il serait préférable de le faire en étendant Theme.Dialog, alors vous n'auriez pas à jouer à un jeu de devinettes sur le moment d'appeler setAttributes. (Bien que ce soit un peu plus de travail que la boîte de dialogue adopte automatiquement un thème clair ou sombre approprié, ou le thème Honeycomb Holo. Cela peut être fait selon http://developer.android.com/guide/topics/ui/themes. html # SelectATheme )

Essayez d'envelopper votre disposition de boîte de dialogue personnalisée dans RelativeLayoutau lieu de LinearLayout. Cela a fonctionné pour moi.

La spécification de FILL_PARENT dans la fenêtre de dialogue, comme d'autres l'ont suggéré, n'a pas fonctionné pour moi (sur Android 4.0.4), car elle a simplement étiré l'arrière-plan de la boîte de dialogue noire pour remplir tout l'écran.

Ce qui fonctionne bien, c'est d'utiliser la valeur d'affichage minimale, mais de la spécifier dans le code, de sorte que la boîte de dialogue occupe 90% de l'écran.

Alors:

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 règle générale, seul le réglage de la largeur devrait être suffisant dans la plupart des cas.

Définissez android:minWidthet android:minHeightdans votre vue personnalisée xml. Ceux-ci peuvent forcer l'alerte à ne pas simplement envelopper la taille du contenu. Utiliser une vue comme celle-ci devrait le faire:

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

Encore plus simple:

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

Toutes les autres réponses ici ont du sens, mais elles ne répondaient pas aux besoins de Fabian. Voici ma solution. Ce n'est peut-être pas la solution parfaite, mais cela fonctionne pour moi. Il affiche une boîte de dialogue qui est en plein écran mais vous pouvez spécifier un remplissage en haut, en bas, à gauche ou à droite.

Mettez d'abord ceci dans votre 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>

Comme vous pouvez le voir, j'ai Android: paddingTop = 20dp est fondamentalement ce dont vous avez besoin. L' androïde: windowBackground = @ color / Black0Percent n'est qu'un code couleur déclaré sur mon color.xml

res / values ​​/ color.xml

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

Ce code couleur sert simplement de modèle pour remplacer l'arrière-plan de la fenêtre par défaut de la boîte de dialogue par une couleur de transparence 0%.

Créez ensuite la mise en page de dialogue personnalisée 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>

Enfin, voici notre boîte de dialogue qui définit une vue personnalisée qui utilise notre 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();

Conclusion: j'ai essayé de remplacer le thème de la boîte de dialogue dans le styles.xml nommé CustomDialog. Il remplace la disposition de la fenêtre de dialogue et me donne la possibilité de définir un remplissage et de changer l'opacité de l'arrière-plan. Ce n'est peut-être pas la solution parfaite, mais j'espère que cela vous aidera .. :)

Vous pouvez utiliser le pourcentage pour la largeur de la fenêtre (JUST) des fenêtres.

Regardez cet exemple 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>

Tout ce que vous avez à faire est d'étendre ce thème et de changer les valeurs de "Major" et "Minor" à 90% au lieu de 65%.

Cordialement.

Les éléments suivants ont bien fonctionné pour moi:

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

(note: windowMinWidthMajor / Minor comme suggéré dans les réponses précédentes n'a pas fait l'affaire. Mes boîtes de dialogue changeaient de taille en fonction du contenu)

puis:

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

Solution avec calcul réel à 90%:

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

où getScreenWidth(Activity activity)est défini ce qui suit (mieux placé dans une classe Utils):

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

Obtenez la largeur de l'appareil:

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

puis utilisez-le pour créer un dialogue à 90% de l'appareil,

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

Eh bien, vous devez définir la hauteur et la largeur de votre boîte de dialogue avant de l'afficher (dialog.show ())

alors, faites quelque chose comme ça:

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

//then

dialog.show()

De loin la façon la plus simple à laquelle je puisse penser -

Si votre boîte de dialogue est constituée d'un LinearLayout vertical, ajoutez simplement une vue factice de "remplissage en hauteur", qui occupera toute la hauteur de l'écran.

Par exemple -

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

Remarquez les android:weightSum="1"attributs de LinearLayout et les attributs android:layout_weight="1"de la vue factice

Eh bien, vous devez définir la hauteur et la largeur de votre boîte de dialogue avant de l'afficher (dialog.show ())

alors, faites quelque chose comme ça:

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

//then

dialog.show()

En obtenant ce code, j'ai fait quelques changements:

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

cependant, la taille de la boîte de dialogue peut changer lorsque l'appareil change de position. Peut-être devez-vous gérer vous-même les changements de métriques. PD: peekDecorView, implique que la mise en page dans l'activité est correctement initialisée sinon vous pouvez utiliser

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

afin d'obtenir la taille de l'écran

Après avoir initialisé votre objet de dialogue et défini la vue du contenu. Faites-le et profitez-en.

(dans le cas où je fixe 90% à la largeur et 70% à la hauteur parce que la largeur à 90% sera sur la barre d'outils)

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

Ma réponse est basée sur le koma, mais elle ne nécessite pas de remplacer onStart mais uniquement onCreateView qui est presque toujours remplacé par défaut lorsque vous créez de nouveaux fragments.

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

Je l'ai testé sur Android 5.0.1.

Voici ma variante pour la largeur de la boîte de dialogue personnalisée:

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

Ainsi, en fonction de l'orientation du périphérique ( ThemeHelper.isPortrait(mContext)), la largeur de la boîte de dialogue sera de 95% (pour le mode portrait) ou de 65% (pour le paysage). C'est un peu plus que l'auteur a demandé mais cela pourrait être utile à quelqu'un.

Vous devez créer une classe qui s'étend de Dialog et mettre ce code dans votre onCreate(Bundle savedInstanceState)méthode.

Pour la hauteur de la boîte de dialogue, le code devrait être similaire à ceci.

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

Au-dessus de nombreuses réponses sont bonnes, mais aucune n'a fonctionné pleinement pour moi. J'ai donc combiné la réponse de @nmr et obtenu celle-ci.

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 vous utilisez la disposition des contraintes , vous pouvez définir n'importe quelle vue à l'intérieur, pour remplir un pourcentage de l'écran avec:

layout_constraintWidth_percent = "0.8"

Ainsi, par exemple, si vous avez un ScrollView à l'intérieur de la boîte de dialogue et que vous souhaitez le définir sur un pourcentage de la hauteur de l'écran. Ce serait comme ça:

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

J'espère que cela aide quelqu'un !!

Donnez simplement ce thème à AlertDialog

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

Vous devez utiliser un style @ style.xml tel que CustomDialog pour afficher la boîte de dialogue personnalisable.

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

et utilisez ce style dans Activity.java comme ceci

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

et votre custom_dialog.xml devrait à l'intérieur de votre répertoire de disposition

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

Voici une réponse courte qui a fonctionné pour moi (Testé sur API 8 et 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();

        }
    });