webentwicklung-frage-antwort-db.com.de

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

Ich kann einen benutzerdefinierten Alarmdialog erstellen und anzeigen, aber trotzdem habe ich Android:layout_width/height="fill_parent" in der Dialog-XML nur so groß wie der Inhalt.

Was ich möchte, ist ein Dialog, der den gesamten Bildschirm ausfüllt, außer vielleicht ein Abstand von 20 Pixeln. Dann wird das Bild, das Teil des Dialogs ist, automatisch mit full_parent auf die volle Dialoggröße gedehnt.

250
Fabian

Laut Android-Plattformentwicklerin Dianne Hackborn im this discussion group post, hat Dialogs die oberste Layoutbreite und -höhe des Fensters auf WRAP_CONTENT gesetzt. Um den Dialog zu vergrößern, können Sie diese Parameter auf MATCH_PARENT setzen.

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 wird. Das System ist wählerisch, wann sie eingestellt sind. (Ich denke, dass die Layout-Engine sie einstellen muss, wenn der Dialog zum ersten Mal angezeigt wird oder so.) 

Es wäre besser, dies durch die Erweiterung von Theme.Dialog zu tun, dann müssten Sie nicht raten, wann setAttributes aufgerufen werden muss. (Obwohl es ein bisschen mehr Arbeit ist, das Dialogfeld automatisch ein entsprechendes helles oder dunkles Thema oder das Honeycomb Holo-Thema annehmen zu lassen. Dies kann gemäß http://developer.Android.com/guide/topics/ui/ erfolgen. themes.html # selectATheme )

334
nmr

Versuchen Sie, Ihr benutzerdefiniertes Dialoglayout in RelativeLayout anstatt in LinearLayout einzugeben. Das hat bei mir funktioniert. 

127
cvarsendan

Die Angabe von FILL_PARENT im Dialogfenster, wie von anderen vorgeschlagen, funktionierte für mich nicht (unter Android 4.0.4), da der schwarze Hintergrund des Dialogs so gedehnt wurde, dass er den gesamten Bildschirm ausfüllte.

Was gut funktioniert, ist die Verwendung des minimalen Anzeigewerts, aber die Angabe innerhalb des Codes, so dass der Dialog 90% des Bildschirms beansprucht.

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 Breite angepasst werden.

79
koma

Legen Sie Android:minWidth und Android:minHeight in Ihrer benutzerdefinierten XML-Ansicht fest. Diese können dazu führen, dass die Warnung nicht nur die Inhaltsgröße umschließt. Eine Ansicht wie diese sollte es 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>
76
jqpubliq
dialog.getWindow().setLayout(LayoutParams.FILL_PARENT, LayoutParams.FILL_PARENT);
49
Elvis

Noch einfacher tun Sie dies einfach:

int width = (int)(getResources().getDisplayMetrics().widthPixels*0.90);
int height = (int)(getResources().getDisplayMetrics().heightPixels*0.90);

alertDialog.getWindow().setLayout(width, height);
48
FOMDeveloper

Alle anderen Antworten sind sinnvoll, entsprechen aber 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 zeigt einen Dialog, der sich im Vollbildmodus befindet, Sie können jedoch eine Auffüllung oben, unten, links oder rechts angeben.

Fügen Sie dies zunächst 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 da Android: paddingTop = 20dp ist im Grunde das, was Sie brauchen. Das Android: windowBackground = @ color/Black0Percent ist nur ein in meiner color.xml deklarierter Farbcode

res/values ​​/ color.xml

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

Dieser Farbcode dient lediglich als Platzhalter, um den Standardfensterhintergrund des Dialogfelds durch eine Transparenzfarbe von 0% zu ersetzen.

Als Nächstes erstellen Sie 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 einstellt, 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 Design des Dialogs in der 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 Ihnen .. :)

22
icaneatclouds

Sie können den Prozentsatz für die Fensterbreite (JUST) des Fensters verwenden.

Schauen Sie sich dieses Beispiel von Holo Theme 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>

Alles, was Sie tun müssen, ist, dieses Thema zu erweitern und die Werte für "Major" und "Minor" auf 90% zu ändern, statt auf 65%.

Grüße.

18
Joao Gavazzi

Folgendes funktionierte gut für mich:

    <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 bewältigt. Meine Dialoge haben ihre Größe je nach Inhalt geändert)

und dann:

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

Lösung mit aktueller 90% Berechnung:

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

dabei ist getScreenWidth(Activity activity) wie folgt 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;
}
14
Mehmet K

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

so etwas tun:

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

//then

dialog.show()
7
shontauro

Bei weitem der einfachste Weg, den ich mir vorstellen kann -

Wenn Ihr Dialogfeld aus einem vertikalen LinearLayout besteht, fügen Sie einfach eine Dummy-Ansicht "Höhe füllen" 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 Sie den Android:weightSum="1" in den Attributen des LinearLayout und den Android:layout_weight="1" in den Attributen der Dummy-Ansicht

6
Ron Tesler

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

(Für den Fall, dass ich 90% auf Breite und 70% auf Höhe einstelle, weil 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();
4

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

so etwas tun:

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

//then

dialog.show()

Als ich diesen Code bekam, habe ich einige Änderungen vorgenommen:

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

die Größe des Dialogs kann sich jedoch ändern, wenn das Gerät seine Position ändert. Möglicherweise müssen Sie bei der Änderung von Metriken selbst vorgehen. PD: peekDecorView bedeutet, dass das Layout in Activity ordnungsgemäß initialisiert wird 

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

um Bildschirmgröße zu erhalten

4
Juan Otero

Meine Antwort basiert auf der Koma, sie muss jedoch nicht onStart überschreiben, sondern nur onCreateView, das fast immer standardmäßig überschrieben wird, wenn Sie neue Fragmente erstellen.

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

3
Kresimir Plese

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

dann verwenden Sie das für den Dialog 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();
3
Gopinath
    ...
    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
2
Guihgo
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;
        }
    }
2
Krunal Shah

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

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

Abhängig von der Geräteorientierung (ThemeHelper.isPortrait(mContext)) beträgt die Breite des Dialogs entweder 95% (für Hochformat) oder 65% (für Querformat). Der Autor hat etwas mehr gefragt, aber es könnte für jemanden nützlich sein.

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

Für die Höhe des Dialogs sollte der Code diesem ähneln.

2
Clans

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

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

sie müssen style @ style.xml wie CustomDialog verwenden, um das anpassbare Dialogfeld 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>
0
Nuwan Withanage

Hier ist eine kurze Antwort, die für mich funktioniert hat (Getestet mit 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);
0
Tanasis