Come fare in modo che una finestra di dialogo di avviso riempia il 90% delle dimensioni dello schermo?

Posso creare e visualizzare una finestra di avviso personalizzata bene ma anche così android:layout_width/height="fill_parent" nella finestra di dialogo xml è grande solo quanto il contenuto.

Quello che voglio è una finestra di dialogo che riempia l'intero schermo tranne forse un'imbottitura di 20 pixel. Quindi l'immagine che fa parte della finestra di dialogo si estenderebbe automaticamente alla dimensione completa della finestra di dialogo con fill_parent.

Secondo lo sviluppatore della piattaforma Android Dianne Hackborn in questo post del gruppo di discussione, Dialogs imposta la larghezza e l'altezza del layout di livello superiore della finestra su WRAP_CONTENT. Per ingrandire la finestra di dialogo, è possibile impostare tali parametri su MATCH_PARENT.

Codice demo:

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

Si noti che gli attributi vengono impostati dopo la visualizzazione della finestra di dialogo. Il sistema è pignolo quando sono impostati. (Immagino che il motore di layout debba impostarli la prima volta che viene mostrata la finestra di dialogo, o qualcosa del genere.)

Sarebbe meglio farlo estendendo Theme.Dialog, quindi non dovresti giocare a indovinare quando chiamare setAttributes. (Anche se è un po 'più complicato fare in modo che la finestra di dialogo adotti automaticamente un tema chiaro o scuro appropriato, o il tema Honeycomb Holo. Questo può essere fatto secondo http://developer.android.com/guide/topics/ui/themes. html # SelectATheme )

Prova a includere il layout della finestra di dialogo personalizzato in RelativeLayoutanziché LinearLayout. Questo ha funzionato per me.

Specificare FILL_PARENT nella finestra di dialogo, come altri hanno suggerito, non ha funzionato per me (su Android 4.0.4), perché ha semplicemente allungato lo sfondo nero della finestra di dialogo per riempire l'intero schermo.

Ciò che funziona bene è usare il valore minimo di visualizzazione, ma specificandolo nel codice, in modo che la finestra di dialogo occupi il 90% dello schermo.

Così:

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

In generale, solo la regolazione della larghezza dovrebbe essere sufficiente nella maggior parte dei casi.

Imposta android:minWidthe android:minHeightnella tua vista personalizzata xml. Questi possono forzare l'avviso a non limitarsi a contenere le dimensioni del contenuto. Utilizzando una vista come questa dovrebbe farlo:

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

Ancora più semplice, basta fare questo:

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

Tutte le altre risposte qui hanno senso, ma non soddisfano le esigenze di Fabian. Ecco una mia soluzione. Potrebbe non essere la soluzione perfetta ma funziona per me. Mostra una finestra di dialogo che è a schermo intero ma è possibile specificare un'imbottitura in alto, in basso, a sinistra o a destra.

Per prima cosa inseriscilo nel tuo res / valori / 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>

Come puoi vedere, ho Android: paddingTop = 20dp è fondamentalmente quello che ti serve. L' androide: windowBackground = @ color / Black0Percent è solo un codice colore dichiarato sul mio color.xml

res / valori / color.xml

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

Quel codice colore serve solo da manichino per sostituire lo sfondo predefinito della finestra di dialogo con un colore di trasparenza dello 0%.

Quindi crea il layout di dialogo personalizzato 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>

Infine ecco la nostra finestra di dialogo che imposta la visualizzazione personalizzata che utilizza il nostro 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();

Conclusione: ho provato a sovrascrivere il tema della finestra di dialogo in styles.xml denominato CustomDialog. Sovrascrive il layout della finestra di dialogo e mi dà la possibilità di impostare un'imbottitura e modificare l'opacità dello sfondo. Potrebbe non essere la soluzione perfetta ma spero che ti aiuti .. :)

È possibile utilizzare la percentuale per la larghezza della finestra di dialogo (SOLO).

Guarda questo esempio dal tema 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>

Tutto quello che devi fare è estendere questo tema e cambiare i valori di "Maggiore" e "Minore" al 90% anziché al 65%.

Saluti.

Quanto segue ha funzionato bene per me:

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

(nota: windowMinWidthMajor / Minor come suggerito nelle risposte precedenti non ha funzionato. I miei dialoghi continuavano a cambiare dimensione a seconda del contenuto)

e poi:

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

Soluzione con calcolo effettivo del 90%:

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

dove getScreenWidth(Activity activity)è definito quanto segue (meglio inserito in una classe Utils):

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

Ottieni la larghezza 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;
}

quindi usalo per rendere la finestra di dialogo il 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();

Bene, devi impostare l'altezza e la larghezza della finestra di dialogo prima di mostrare questo (dialog.show ())

quindi, fai qualcosa del genere:

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

//then

dialog.show()

Di gran lunga il modo più semplice che mi viene in mente -

Se la finestra di dialogo è composta da un layout lineare lineare, è sufficiente aggiungere una vista fittizia "riempimento di altezza", che occuperà l'intera altezza dello schermo.

Per esempio -

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

Notare gli android:weightSum="1"attributi in LinearLayout e gli attributi android:layout_weight="1"nella vista fittizia

Bene, devi impostare l'altezza e la larghezza della finestra di dialogo prima di mostrare questo (dialog.show ())

quindi, fai qualcosa del genere:

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

//then

dialog.show()

Ottenendo questo codice, ho apportato alcune modifiche:

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

tuttavia, le dimensioni della finestra di dialogo potrebbero cambiare quando il dispositivo cambia posizione. Forse devi gestire da solo quando le metriche cambiano. PD: peekDecorView, implica che il layout in attività sia correttamente inizializzato, altrimenti è possibile utilizzarlo

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

per ottenere le dimensioni dello schermo

Dopo aver inizializzato l'oggetto della finestra di dialogo e impostato la visualizzazione del contenuto. Fallo e divertiti.

(nel caso in cui sto impostando il 90% in larghezza e il 70% in altezza perché la larghezza del 90% sarà sulla barra degli strumenti)

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

La mia risposta si basa su quella di Koma ma non richiede di sovrascrivere su Start ma solo su Crea visualizzazione che è quasi sempre sovrascritta di default quando crei nuovi frammenti.

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

L'ho provato su Android 5.0.1.

Ecco la mia variante per la larghezza della finestra di dialogo personalizzata:

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

Quindi, a seconda dell'orientamento del dispositivo (ThemeHelper.isPortrait(mContext) ), la larghezza della finestra di dialogo sarà del 95% (per la modalità verticale) o del 65% (per orizzontale). È un po 'di più che l'autore ha chiesto ma potrebbe essere utile a qualcuno.

Devi creare una classe che si estende da Dialog e inserire questo codice nel tuo onCreate(Bundle savedInstanceState) metodo.

Per l'altezza della finestra di dialogo il codice dovrebbe essere simile a questo.

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

Sopra molte delle risposte sono buone, ma nessuna delle ha funzionato per me pienamente. Quindi ho combinato la risposta di @nmr e ho ottenuto questo.

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

Se stai utilizzando il layout del vincolo , puoi impostare qualsiasi vista al suo interno, per riempire una percentuale dello schermo con:

layout_constraintWidth_percent = "0,8"

Quindi, ad esempio, se nella finestra di dialogo è presente uno ScrollView e si desidera impostarlo su una percentuale dell'altezza dello schermo. Sarebbe così:

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

Spero che aiuti qualcuno !!

Dai a questo AlertDialog questo 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>

È necessario utilizzare uno stile @ style.xml come CustomDialog per visualizzare la finestra di dialogo personalizzabile.

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

e usa questo stile in Activity.java in questo modo

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

e custom_dialog.xml dovrebbe trovarsi nella directory del layout

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

Ecco una breve risposta che ha funzionato per me (testato su API 8 e 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();

        }
    });