Android studio dialog height

How to control the width and height of the default Alert Dialog in Android?

I am using the above code to display an Alert Dialog. By default, it fills the screen in width and wrap_content in height.
How can I control the width and height of default alert dialog ?
I tried:

How to get the layout params on the alert window and manually set the width and height?

11 Answers 11

Only a slight change in Sat Code, set the layout after show() method of AlertDialog .

Or you can do it in my way.

Ok , I can control the width and height using Builder class. I used

For those who will find this thread like me, here is IMO better solution (note the 70% which sets min width of the dialog in percent of screen width):

And then apply this style to dialog:

Before trying to adjust the size post-layout, first check what style your dialog is using. Make sure that nothing in the style tree sets

If that’s happening, it’s just as simple as supplying your own style to the [builder constructor that takes in a themeResId](http://developer.android.com/reference/android/app/AlertDialog.Builder.html#AlertDialog.Builder(android.content.Context, int)) available API 11+

This works as well by adding .getWindow().setLayout(width, height) after show()

If you wanna add dynamic width and height based on your device frame, you can do these calculations and assign the height and width.

P.S : Show the dialog first and then try to modify the window’s layout attributes

Appreciate answered by Sid because its dynamic but I want to add something.

What if you want to change width only, height will be as it is.

I have done like following:

Here I used alert.getWindow().getAttributes().height to keep height as it is of AlertDialog and Width will be changed as per screen resolution.

Hope it will helps. Thanks.

I dont know whether you can change the default height/width of AlertDialog but if you wanted to do this, I think you can do it by creating your own custom dialog. You just have to give android:theme=»@android:style/Theme.Dialog» in the android manifest.xml for your activity and can write the whole layout as per your requirement. you can set the height and width of your custom dialog from the Android Resource XML.

I think tir38’s answer is the cleanest solution. Have in mind that if you are using android.app.AlerDialog and holo themes your style should look like this

And if using support.v7.app.AlertDialog or androidx.appcompat.app.AlertDialog with AppCompat theme your style should look like this

It took me a long time to get this working how I wanted it to. This code made it so that almost the whole screen width is filled with the dialog which is what I wanted.

Источник

How to set DialogFragment’s width and height?

Let’s say I specify the layout of my DialogFragment in an xml layout file named my_dialog_fragment.xml and I specify the layout_width and layout_height values of its root view to a fixed value (e.g. 100dp ). I then inflate this layout in my DialogFragment ‘s onCreateView(. ) method as follows:

Sadly, I find that when my DialogFragment appears, it does not respect the layout_width and layout_height values specified in its xml layout file and thus it shrinks or expands depending on its content. Anyone know whether or how I can get my DialogFragment to respect the layout_width and layout_height values specified in its xml layout file? At the moment I’m having to specify the width and height of the Dialog again in my DialogFragment ‘s onResume() method as follows:

The problem with this is that I have to remember to make any future changes to the width and height in two places.

28 Answers 28

If you convert directly from resources values:

Then specify match_parent in your layout for the dialog:

You only have to worry about one place (place it in your DialogFragment#onResume ). Its not perfect, but at least it works for having a RelativeLayout as the root of your dialog’s layout file.

I ended up overriding Fragment.onResume() and grabbing the attributes from the underlying dialog, then setting width/height params there. I set the outermost layout height/width to match_parent . Note that this code seems to respect the margins I defined in the xml layout as well.

I got a fixed size DialogFragment defining the following in the XML main layout (LinearLayout in my case):

UPDATE 2021

For Kotlin users, I’ve crafted a couple of simple extension methods that will set the width of your DialogFragment to either a percentage of the screen width, or near full screen:

Then in your DialogFragment in or after onActivityCreated :

Consider the remainder of this answer for posterity.

Gotcha #13: DialogFragment Layouts

It’s sort of mind numbing really.

When creating a DialogFragment , you can choose to override onCreateView (which passes a ViewGroup to attach your .xml layout to) or onCreateDialog , which does not.

You mustn’t override both methods though, because you will very likely confuse Android as to when or if your dialog’s layout was inflated! WTF?

The choice of whether to override OnCreateView or OnCreateDialog depends on how you intend to use the dialog.

• If you intend to allow the DialogFragment to control the rendering of its own internal Dialog , then you are expected to override OnCreateView .
• If you intend to manually control how the DialogFragment ‘s Dialog will be rendered, you are expected to override OnCreateDialog .

This is possibly the worst thing in the world.

onCreateDialog Insanity

So, you’re overriding onCreateDialog in your DialogFragment to create a customized instance of AlertDialog to display in a window. Cool. But remember, onCreateDialog receives no ViewGroup to attach your custom .xml layout to. No problem, you simply pass null to the inflate method.

Let the madness begin.

When you override onCreateDialog , Android COMPLETELY IGNORES several attributes of the root node of the .xml Layout you inflate. This includes, but probably isn’t limited to:

• background_color
• layout_gravity
• layout_width
• layout_height

This is almost comical, as you are required to set the layout_width and layout_height of EVERY .xml Layout or Android Studio will slap you with a nice little red badge of shame.

Just the word DialogFragment makes me want to puke. I could write a novel filled with Android gotchas and snafus, but this one is one of the most insideous.

To return to sanity, first, we declare a style to restore JUST the background_color and layout_gravity we expect:

The style above inherits from the base theme for Dialogs (in the AppCompat theme in this example).

Next, we apply the style programmatically to put back the values Android just tossed aside and to restore the standard AlertDialog look and feel:

The code above will make your AlertDialog look like an AlertDialog again. Maybe this is good enough.

But wait, there’s more!

If you’re looking to set a SPECIFIC layout_width or layout_height for your AlertDialog when it’s shown (very likely), then guess what, you ain’t done yet!

The hilarity continues as you realize that if you attempt to set a specific layout_width or layout_height in your fancy new style, Android will completely ignore that, too!:

To set a SPECIFIC window width or height, you get to head on over to a whole ‘nuther method and deal with LayoutParams :

Many folks follow Android’s bad example of casting WindowManager.LayoutParams up to the more general ViewGroup.LayoutParams , only to turn right around and cast ViewGroup.LayoutParams back down to WindowManager.LayoutParams a few lines later. Effective Java be damned, that unnecessary casting offers NOTHING other than making the code even harder to decipher.

Side note: There are some TWENTY repetitions of LayoutParams across the Android SDK — a perfect example of radically poor design.

In Summary

For DialogFragment s that override onCreateDialog :

• To restore the standard AlertDialog look and feel, create a style that sets background_color = transparent and layout_gravity = center and apply that style in onCreateDialog .
• To set a specific layout_width and/or layout_height , do it programmatically in onResume with LayoutParams
• To maintain sanity, try not to think about the Android SDK.

Источник

Android get full width for custom Dialog

in my application my created custom dialog dont have full height and i can not change and customize that.for example see this screen shot:

My code:

17 Answers 17

You need to get the current Window and set it’s LayoutParams like so:

Alternative(if above solution does’t works)

In case above code not works well you can use a workaround

Two ways this can be done, first one in style.xml and second in code:

1. Add as below in style.xml, alter the value(currently 90%) to meet your needs.

For full width dialog you can create custom style for dialog. Code is given below for full width dialog:

To assign this style to the dialog’s constructor, add this to onCreate() method right after setContentView() :

In case anyone is wondering how to do it for a dialog shown using DialogFragment , you can override onCreateDialog to return a Dialog with custom style that has windowMinWidthMajor and minor set to 90%

You don’t need to add any style for that just try below one

Note: using empty style is memory time consuming inside the processor. Instead directly use dailog.getWindow().setLayout(width,height) .

Use Relative Layout instead of Linear layout to get full width of Custom Dialog.

Just try to wrap your dialog layout in a RelativeLayout

In my case width of custom dialog shrinks in size(width) as the content inside dialog becomes smaller in width even though the the width property was set

I just fixed that width to screen size and now its working according to my requirement

Источник

Dialogs

In this document

Key classes

See also

A dialog is a small window that prompts the user to make a decision or enter additional information. A dialog does not fill the screen and is normally used for modal events that require users to take an action before they can proceed.

Dialog Design

For information about how to design your dialogs, including recommendations for language, read the Dialogs design guide.

The Dialog class is the base class for dialogs, but you should avoid instantiating Dialog directly. Instead, use one of the following subclasses:

AlertDialog A dialog that can show a title, up to three buttons, a list of selectable items, or a custom layout. DatePickerDialog or TimePickerDialog A dialog with a pre-defined UI that allows the user to select a date or time.

Avoid ProgressDialog

Android includes another dialog class called ProgressDialog that shows a dialog with a progress bar. However, if you need to indicate loading or indeterminate progress, you should instead follow the design guidelines for Progress & Activity and use a ProgressBar in your layout.

These classes define the style and structure for your dialog, but you should use a DialogFragment as a container for your dialog. The DialogFragment class provides all the controls you need to create your dialog and manage its appearance, instead of calling methods on the Dialog object.

Using DialogFragment to manage the dialog ensures that it correctly handles lifecycle events such as when the user presses the Back button or rotates the screen. The DialogFragment class also allows you to reuse the dialog’s UI as an embeddable component in a larger UI, just like a traditional Fragment (such as when you want the dialog UI to appear differently on large and small screens).

The following sections in this guide describe how to use a DialogFragment in combination with an AlertDialog object. If you’d like to create a date or time picker, you should instead read the Pickers guide.

Note: Because the DialogFragment class was originally added with Android 3.0 (API level 11), this document describes how to use the DialogFragment class that’s provided with the Support Library. By adding this library to your app, you can use DialogFragment and a variety of other APIs on devices running Android 1.6 or higher. If the minimum version your app supports is API level 11 or higher, then you can use the framework version of DialogFragment , but be aware that the links in this document are for the support library APIs. When using the support library, be sure that you import android.support.v4.app.DialogFragment class and not android.app.DialogFragment .

Creating a Dialog Fragment

You can accomplish a wide variety of dialog designs—including custom layouts and those described in the Dialogs design guide—by extending DialogFragment and creating a AlertDialog in the onCreateDialog() callback method.

For example, here’s a basic AlertDialog that’s managed within a DialogFragment :

Figure 1. A dialog with a message and two action buttons.

Now, when you create an instance of this class and call show() on that object, the dialog appears as shown in figure 1.

The next section describes more about using the AlertDialog.Builder APIs to create the dialog.

Depending on how complex your dialog is, you can implement a variety of other callback methods in the DialogFragment , including all the basic fragment lifecycle methods.

Building an Alert Dialog

The AlertDialog class allows you to build a variety of dialog designs and is often the only dialog class you’ll need. As shown in figure 2, there are three regions of an alert dialog:

Figure 2. The layout of a dialog.

This is optional and should be used only when the content area is occupied by a detailed message, a list, or custom layout. If you need to state a simple message or question (such as the dialog in figure 1), you don’t need a title.
Content area

This can display a message, a list, or other custom layout.

There should be no more than three action buttons in a dialog.

The AlertDialog.Builder class provides APIs that allow you to create an AlertDialog with these kinds of content, including a custom layout.

The following topics show how to define various dialog attributes using the AlertDialog.Builder class.

Adding buttons

To add action buttons like those in figure 2, call the setPositiveButton() and setNegativeButton() methods:

The set. Button() methods require a title for the button (supplied by a string resource) and a DialogInterface.OnClickListener that defines the action to take when the user presses the button.

There are three different action buttons you can add:

Positive You should use this to accept and continue with the action (the «OK» action). Negative You should use this to cancel the action. Neutral You should use this when the user may not want to proceed with the action, but doesn’t necessarily want to cancel. It appears between the positive and negative buttons. For example, the action might be «Remind me later.»

You can add only one of each button type to an AlertDialog . That is, you cannot have more than one «positive» button.

Figure 3. A dialog with a title and list.

Adding a list

There are three kinds of lists available with the AlertDialog APIs:

• A traditional single-choice list
• A persistent single-choice list (radio buttons)
• A persistent multiple-choice list (checkboxes)

To create a single-choice list like the one in figure 3, use the setItems() method:

Because the list appears in the dialog’s content area, the dialog cannot show both a message and a list and you should set a title for the dialog with setTitle() . To specify the items for the list, call setItems() , passing an array. Alternatively, you can specify a list using setAdapter() . This allows you to back the list with dynamic data (such as from a database) using a ListAdapter .

If you choose to back your list with a ListAdapter , always use a Loader so that the content loads asynchronously. This is described further in Building Layouts with an Adapter and the Loaders guide.

Note: By default, touching a list item dismisses the dialog, unless you’re using one of the following persistent choice lists.

Figure 4. A list of multiple-choice items.

Adding a persistent multiple-choice or single-choice list

To add a list of multiple-choice items (checkboxes) or single-choice items (radio buttons), use the setMultiChoiceItems() or setSingleChoiceItems() methods, respectively.

For example, here’s how you can create a multiple-choice list like the one shown in figure 4 that saves the selected items in an ArrayList :

Although both a traditional list and a list with radio buttons provide a «single choice» action, you should use setSingleChoiceItems() if you want to persist the user’s choice. That is, if opening the dialog again later should indicate what the user’s current choice is, then you create a list with radio buttons.

Creating a Custom Layout

Figure 5. A custom dialog layout.

If you want a custom layout in a dialog, create a layout and add it to an AlertDialog by calling setView() on your AlertDialog.Builder object.

By default, the custom layout fills the dialog window, but you can still use AlertDialog.Builder methods to add buttons and a title.

For example, here’s the layout file for the dialog in Figure 5:

Tip: By default, when you set an EditText element to use the «textPassword» input type, the font family is set to monospace, so you should change its font family to «sans-serif» so that both text fields use a matching font style.

To inflate the layout in your DialogFragment , get a LayoutInflater with getLayoutInflater() and call inflate() , where the first parameter is the layout resource ID and the second parameter is a parent view for the layout. You can then call setView() to place the layout in the dialog.

Tip: If you want a custom dialog, you can instead display an Activity as a dialog instead of using the Dialog APIs. Simply create an activity and set its theme to Theme.Holo.Dialog in the manifest element:

That’s it. The activity now displays in a dialog window instead of fullscreen.

Passing Events Back to the Dialog’s Host

When the user touches one of the dialog’s action buttons or selects an item from its list, your DialogFragment might perform the necessary action itself, but often you’ll want to deliver the event to the activity or fragment that opened the dialog. To do this, define an interface with a method for each type of click event. Then implement that interface in the host component that will receive the action events from the dialog.

For example, here’s a DialogFragment that defines an interface through which it delivers the events back to the host activity:

The activity hosting the dialog creates an instance of the dialog with the dialog fragment’s constructor and receives the dialog’s events through an implementation of the NoticeDialogListener interface:

Because the host activity implements the NoticeDialogListener —which is enforced by the onAttach() callback method shown above—the dialog fragment can use the interface callback methods to deliver click events to the activity:

Showing a Dialog

When you want to show your dialog, create an instance of your DialogFragment and call show() , passing the FragmentManager and a tag name for the dialog fragment.

The second argument, «missiles» , is a unique tag name that the system uses to save and restore the fragment state when necessary. The tag also allows you to get a handle to the fragment by calling findFragmentByTag() .

Showing a Dialog Fullscreen or as an Embedded Fragment

You might have a UI design in which you want a piece of the UI to appear as a dialog in some situations, but as a full screen or embedded fragment in others (perhaps depending on whether the device is a large screen or small screen). The DialogFragment class offers you this flexibility because it can still behave as an embeddable Fragment .

However, you cannot use AlertDialog.Builder or other Dialog objects to build the dialog in this case. If you want the DialogFragment to be embeddable, you must define the dialog’s UI in a layout, then load the layout in the onCreateView() callback.

Here’s an example DialogFragment that can appear as either a dialog or an embeddable fragment (using a layout named purchase_items.xml ):

And here’s some code that decides whether to show the fragment as a dialog or a fullscreen UI, based on the screen size:

For more information about performing fragment transactions, see the Fragments guide.

In this example, the mIsLargeLayout boolean specifies whether the current device should use the app’s large layout design (and thus show this fragment as a dialog, rather than fullscreen). The best way to set this kind of boolean is to declare a bool resource value with an alternative resource value for different screen sizes. For example, here are two versions of the bool resource for different screen sizes:

Then you can initialize the mIsLargeLayout value during the activity’s onCreate() method:

Showing an activity as a dialog on large screens

Instead of showing a dialog as a fullscreen UI when on small screens, you can accomplish the same result by showing an Activity as a dialog when on large screens. Which approach you choose depends on your app design, but showing an activity as a dialog is often useful when your app is already designed for small screens and you’d like to improve the experience on tablets by showing a short-lived activity as a dialog.

To show an activity as a dialog only when on large screens, apply the Theme.Holo.DialogWhenLarge theme to the manifest element:

For more information about styling your activities with themes, see the Styles and Themes guide.

Dismissing a Dialog

When the user touches any of the action buttons created with an AlertDialog.Builder , the system dismisses the dialog for you.

The system also dismisses the dialog when the user touches an item in a dialog list, except when the list uses radio buttons or checkboxes. Otherwise, you can manually dismiss your dialog by calling dismiss() on your DialogFragment .

In case you need to perform certain actions when the dialog goes away, you can implement the onDismiss() method in your DialogFragment .

You can also cancel a dialog. This is a special event that indicates the user explicitly left the dialog without completing the task. This occurs if the user presses the Back button, touches the screen outside the dialog area, or if you explicitly call cancel() on the Dialog (such as in response to a «Cancel» button in the dialog).

As shown in the example above, you can respond to the cancel event by implementing onCancel() in your DialogFragment class.

Источник