Wie kann ein Warndialog 90% der Bildschirmgröße ausfüllen?

Ich kann ein benutzerdefiniertes Warnungsdialogfeld erstellen und anzeigen, aber trotzdem ist es android:layout_width/height="fill_parent"im Dialog-XML nur so groß wie der Inhalt.

Was ich möchte, ist ein Dialog, der den gesamten Bildschirm ausfüllt, außer vielleicht eine Auffüllung von 20 Pixel. Dann wird das Bild, das Teil des Dialogfelds ist, mit fill_parent automatisch auf die volle Dialogfeldgröße ausgedehnt.

Laut der Entwicklerin der Android-Plattform, Dianne Hackborn , haben Dialoge in diesem Diskussionsgruppenbeitrag die Breite und Höhe des Layouts ihres Fensters auf oberster Ebene auf festgelegt WRAP_CONTENT. Um den Dialog zu vergrößern, können Sie diese Parameter auf einstellen MATCH_PARENT.

Demo-Code:

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

Beachten Sie, dass die Attribute festgelegt werden, nachdem der Dialog angezeigt wurde. Das System ist pingelig, wenn sie eingestellt sind. (Ich denke, dass die Layout-Engine sie festlegen muss, wenn der Dialog zum ersten Mal angezeigt wird, oder so.)

Es wäre besser, dies durch Erweitern von Theme.Dialog zu tun, dann müssten Sie kein Ratespiel darüber spielen, wann setAttributes aufgerufen werden soll. (Obwohl es etwas aufwendiger ist, wenn der Dialog automatisch ein geeignetes helles oder dunkles Thema oder das Honeycomb Holo-Thema annimmt. Dies kann gemäß http://developer.android.com/guide/topics/ui/themes erfolgen. html # SelectATheme )

Versuchen Sie, Ihr benutzerdefiniertes Dialoglayout in RelativeLayoutstatt zu verpacken LinearLayout. Das hat bei mir funktioniert.

Das Angeben von FILL_PARENT im Dialogfenster, wie von anderen vorgeschlagen, funktionierte bei mir nicht (unter Android 4.0.4), da nur der schwarze Dialoghintergrund gestreckt wurde, um den gesamten Bildschirm auszufüllen.

Was gut funktioniert, ist, den minimalen Anzeigewert zu verwenden, ihn jedoch im Code anzugeben, sodass der Dialog 90% des Bildschirms einnimmt.

So:

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

Im Allgemeinen sollte in den meisten Fällen nur die Einstellung der Breite ausreichen.

Stellen Sie android:minWidthund android:minHeightin Ihrer benutzerdefinierten Ansicht XML. Diese können die Warnung zwingen, nicht nur die Inhaltsgröße einzuschließen. Wenn Sie eine Ansicht wie diese verwenden, sollten Sie Folgendes tun:

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

Noch einfacher machen Sie dies einfach:

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

Alle anderen Antworten hier sind sinnvoll, aber sie entsprachen nicht den Anforderungen von Fabian. Hier ist eine Lösung von mir. Es ist vielleicht nicht die perfekte Lösung, aber es funktioniert für mich. Es wird ein Dialogfeld angezeigt, das im Vollbildmodus angezeigt wird. Sie können jedoch oben, unten, links oder rechts eine Auffüllung festlegen.

Fügen Sie dies zuerst in Ihre res / values ​​/ styles.xml ein:

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

Wie Sie sehen können, habe ich dort Android: paddingTop = 20dp ist im Grunde das, was Sie brauchen. Das android: windowBackground = @ color / Black0Percent ist nur ein Farbcode, der in meiner color.xml deklariert ist

res / values ​​/ color.xml

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

Dieser Farbcode dient nur als Dummy, um den Standardfensterhintergrund des Dialogfelds durch eine 0% Transparenzfarbe zu ersetzen.

Erstellen Sie als Nächstes das benutzerdefinierte Dialoglayout 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>

Schließlich ist hier unser Dialog, der eine benutzerdefinierte Ansicht festlegt, die unsere dialog.xml verwendet:

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

Fazit: Ich habe versucht, das Thema des Dialogfelds in der Datei styles.xml mit dem Namen CustomDialog zu überschreiben. Es überschreibt das Layout des Dialogfensters und gibt mir die Möglichkeit, eine Auffüllung festzulegen und die Deckkraft des Hintergrunds zu ändern. Es ist vielleicht nicht die perfekte Lösung, aber ich hoffe es hilft dir .. :)

Sie können den Prozentsatz für die Dialogbreite von (NUR) Fenstern verwenden.

Schauen Sie sich dieses Beispiel aus dem Holo-Thema an:

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

Sie müssen dieses Thema nur erweitern und die Werte für "Major" und "Minor" auf 90% anstatt auf 65% ändern.

Grüße.

Folgendes hat für mich gut funktioniert:

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

(Hinweis: windowMinWidthMajor / Minor, wie in den vorherigen Antworten vorgeschlagen, hat den Trick nicht ausgeführt. Meine Dialoge haben je nach Inhalt ihre Größe geändert.)

und dann:

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

Lösung mit tatsächlicher 90% Berechnung:

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

Dabei getScreenWidth(Activity activity)wird Folgendes definiert (am besten in einer Utils-Klasse):

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

Holen Sie sich die Gerätebreite:

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

Verwenden Sie dies dann, um den Dialog zu 90% des Geräts zu machen.

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

Nun, Sie müssen vorher die Höhe und Breite Ihres Dialogs einstellen, um dies anzuzeigen (dialog.show ())

Also mach so etwas:

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

//then

dialog.show()

Mit Abstand der einfachste Weg, den ich mir vorstellen kann -

Wenn Ihr Dialogfeld aus einem vertikalen LinearLayout besteht, fügen Sie einfach eine Dummy-Ansicht "Höhenfüllung" hinzu, die die gesamte Höhe des Bildschirms einnimmt.

Zum Beispiel -

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

Beachten android:weightSum="1"Sie die Attribute in LinearLayout und die Attribute android:layout_weight="1"in der Dummy-Ansicht

Nun, Sie müssen vorher die Höhe und Breite Ihres Dialogs einstellen, um dies anzuzeigen (dialog.show ())

Also mach so etwas:

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

//then

dialog.show()

Als ich diesen Code bekam, nahm ich einige Änderungen vor:

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

Die Dialoggröße kann sich jedoch ändern, wenn das Gerät seine Position ändert. Möglicherweise müssen Sie selbst vorgehen, wenn sich Metriken ändern. PD: peekDecorView impliziert, dass das Layout in der Aktivität ordnungsgemäß initialisiert wird, andernfalls können Sie es verwenden

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

um die Bildschirmgröße zu erhalten

Nachdem Sie Ihr Dialogobjekt initialisiert und die Inhaltsansicht festgelegt haben. Mach das und genieße es.

(In dem Fall setze ich 90% auf Breite und 70% auf Höhe, da Breite 90% über der Symbolleiste liegt.)

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

Meine Antwort basiert auf den Komas, muss jedoch nicht onStart überschreiben, sondern nur onCreateView, das beim Erstellen neuer Fragmente fast immer standardmäßig überschrieben wird.

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

Ich habe es auf Android 5.0.1 getestet.

Hier ist meine Variante für die Breite des benutzerdefinierten Dialogfelds:

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

Je nach Ausrichtung des Geräts ( ThemeHelper.isPortrait(mContext)) beträgt die Breite des Dialogfelds entweder 95% (im Hochformat) oder 65% (im Querformat). Es ist ein bisschen mehr, als der Autor gefragt hat, aber es könnte für jemanden nützlich sein.

Sie müssen eine Klasse erstellen, die sich aus Dialog erstreckt, und diesen Code in Ihre onCreate(Bundle savedInstanceState)Methode einfügen .

Für die Höhe des Dialogfelds sollte der Code ähnlich sein.

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

Oben sind viele der Antworten gut, aber keine hat für mich voll funktioniert. Also habe ich die Antwort von @nmr kombiniert und diese bekommen.

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

Sie müssen einen style @ style.xml wie CustomDialog verwenden, um den anpassbaren Dialog anzuzeigen.

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

und verwenden Sie diesen Stil in Activity.java wie folgt

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

und Ihre custom_dialog.xml sollte sich in Ihrem Layoutverzeichnis befinden

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

Wenn Sie das Einschränkungslayout verwenden , können Sie eine beliebige Ansicht darin festlegen, um einen Prozentsatz des Bildschirms mit folgenden Inhalten zu füllen:

layout_constraintWidth_percent = "0.8"

Wenn Sie beispielsweise eine Bildlaufansicht im Dialogfeld haben und diese auf einen Prozentsatz der Bildschirmhöhe festlegen möchten. Es wäre so:

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

Hoffe es hilft jemandem !!

Geben Sie dem AlertDialog einfach dieses Thema

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

Hier ist eine kurze Antwort, die für mich funktioniert hat (Getestet auf API 8 und 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();

        }
    });