Я могу создать и отобразить настраиваемое диалоговое окно с предупреждением, но даже в этом случае у меня android:layout_width/height="fill_parent" в диалоговом окне xml оно будет размером с содержимое.
Мне нужен диалог, заполняющий весь экран, за исключением, возможно, заполнения 20 пикселей. Затем изображение, которое является частью диалога, автоматически растягивается до полного размера диалога с помощью fill_parent.
Согласно разработчику платформы Android Dianne Hackborn в этой группе обсуждения, Dialogs установили ширину и высоту макета верхнего уровня окна до WRAP_CONTENT. Чтобы увеличить диалог, вы можете установить эти параметры на MATCH_PARENT.
Демо-код:
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);
Обратите внимание, что атрибуты задаются после отображения диалогового окна. Система очень сложна, когда они установлены. (Я предполагаю, что механизм компоновки должен установить их при первом отображении диалога или что-то в этом роде.)
Было бы лучше сделать это, расширив тему .Dialog, тогда вам не пришлось бы играть в гадательную игру о том, когда нужно позвонить setAttributes. (Хотя это немного больше работы, чтобы диалог автоматически применял соответствующую светлую или темную тему или тему Honeycomb Holo. Это можно сделать в соответствии с http://developer.android.com/guide/topics/ui/themes.html#SelectATheme)
Попробуйте обернуть свой собственный диалог в RelativeLayout вместо LinearLayout. Это сработало для меня.
Задание FILL_PARENT в диалоговом окне, как и другие, не работает для меня (на Android 4.0.4), потому что он просто растянул черный диалог, чтобы заполнить весь экран.
Хорошо работает минимальное отображаемое значение, но указывая его внутри кода, так что диалог занимает 90% экрана.
Итак:
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);
Обычно в большинстве случаев регулировка ширины должна быть достаточной.
Установите android:minWidth и android:minHeight в свой пользовательский вид xml. Они могут заставить предупреждение не просто обернуть размер содержимого.
Использование такого вида должно сделать это:
<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>
Еще проще:
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);
Все остальные ответы здесь имеют смысл, но это не соответствует тому, что нужно Фабиану. Вот мое решение. Это может быть не идеальное решение, но оно работает для меня. Он показывает диалог, который находится в полноэкранном режиме, но вы можете указать отступы сверху, снизу, слева или справа.
Сначала поместите это в свои 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>
Как вы можете видеть, у меня есть андроид: paddingTop = 20dp - это в основном то, что вам нужно. android: windowBackground = @color/Black0Percent - это только цветовой код, объявленный на моем color.xml
RES/значения/color.xml
<?xml version="1.0" encoding="utf-8"?>
<resources>
<color name="Black0Percent">#00000000</color>
</resources>
Этот цветовой код просто служит фиктивным для замены фона окна по умолчанию диалогового окна с цветом прозрачности 0%.
Затем создайте собственный диалог диалога 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>
Наконец, вот наш диалог, который устанавливает пользовательский вид, который использует наш 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();
Заключение: Я попытался переопределить тему диалога в файле styles.xml с именем CustomDialog. Он переопределяет макет окна диалогового окна и дает мне возможность установить дополнение и изменить непрозрачность фона. Возможно, это не идеальное решение, но я надеюсь, что это вам поможет.:)
Вы можете использовать процентное соотношение для ширины окна (JUST) окна.
Посмотрите этот пример с темы 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 desired minimum size for a dialog 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>
Все, что вам нужно сделать, это расширить эту тему и изменить значения "Major" и "Minor" на 90% вместо 65%.
С уважением.
Следующее работало отлично для меня:
<style name="MyAlertDialogTheme" parent="Base.Theme.AppCompat.Light.Dialog.Alert">
<item name="windowFixedWidthMajor">90%</item>
<item name="windowFixedWidthMinor">90%</item>
</style>
(примечание: windowMinWidthMajor/Minor, как было предложено в предыдущих ответах, не выполняло трюк. Мои диалоги менялись в зависимости от содержимого)
а затем:
AlertDialog.Builder builder = new AlertDialog.Builder(getActivity(), R.style.MyAlertDialogTheme);
Решение с фактическим 90% вычислением:
@Override public void onStart() {
Dialog dialog = getDialog();
if (dialog != null) {
dialog.getWindow()
.setLayout((int) (getScreenWidth(getActivity()) * .9), ViewGroup.LayoutParams.MATCH_PARENT);
}
}
где getScreenWidth(Activity activity) определяется следующим образом (лучше всего в классе Utils):
public static int getScreenWidth(Activity activity) {
Point size = new Point();
activity.getWindowManager().getDefaultDisplay().getSize(size);
return size.x;
}
Ну, вы должны установить высоту и ширину диалога, прежде чем показывать это (dialog.show())
Итак, сделайте что-то вроде этого:
dialog.getWindow().setLayout(width, height);
//then
dialog.show()
Получите ширину устройства:
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;
}
затем используйте это для создания диалога на 90% устройства,
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();
На самом деле самый простой способ, о котором я могу думать -
Если ваше диалоговое окно сделано из вертикального LinearLayout, просто добавьте фиктивное представление высоты заполнения, которое будет занимать всю высоту экрана.
Например -
<?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>
Обратите внимание на android:weightSum="1" в атрибутах LinearLayout и android:layout_weight="1" в фиктивных атрибутах View
Ну, вы должны установить высоту и ширину диалога, прежде чем показывать это (dialog.show())
Итак, сделайте что-то вроде этого:
dialog.getWindow().setLayout(width, height);
//then
dialog.show()
Получив этот код, я внес некоторые изменения:
dialog.getWindow().setLayout((int)(MapGeaGtaxiActivity.this.getWindow().peekDecorView().getWidth()*0.9),(int) (MapGeaGtaxiActivity.this.getWindow().peekDecorView().getHeight()*0.9));
однако размер диалогового окна может измениться, когда устройство изменит свое положение. Возможно, вам придется обрабатывать свои собственные, когда меняется метрика. PD: peekDecorView, подразумевает, что макет в действии правильно инициализирован, иначе вы можете использовать
DisplayMetrics metrics = new DisplayMetrics();
getWindowManager().getDefaultDisplay().getMetrics(metrics);
int height = metrics.heightPixels;
int wwidth = metrics.widthPixels;
чтобы получить размер экрана
После инициализации вашего объекта диалога и установки представления содержимого. Сделайте это и наслаждайтесь.
(в случае, когда я устанавливаю 90% ширины и 70% к высоте, потому что ширина 90% будет над панелью инструментов)
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();
Мой ответ основан на koma, но он не требует переопределения onStart, но только onCreateView, который по умолчанию почти всегда переопределяется при создании новых фрагментов.
@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;
}
Я тестировал его на Android 5.0.1.
Вот мой вариант для пользовательской ширины диалогового окна:
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);
Таким образом, в зависимости от ориентации устройства (ThemeHelper.isPortrait(mContext)) ширина диалога будет либо 95% (для портретного режима), либо 65% (для пейзажа). Это немного больше, что автор спросил, но может быть кому-то полезен.
Вам нужно создать класс, который простирается от Dialog и поместить этот код в ваш метод onCreate(Bundle savedInstanceState).
Для высоты диалога код должен быть похож на этот.
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;
}
}
Выше многие из ответов хороши, но ни один из них не работал у меня полностью. Поэтому я объединил ответ с @nmr и получил его.
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
Вот короткий ответ, который сработал у меня (протестирован по API 8 и 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);
вам нужно использовать стиль @style.xml, например CustomDialog, для отображения настраиваемого диалогового окна.
<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>
и используйте этот стиль в Activity.java следующим образом
Dialog dialog= new Dialog(Activity.this, R.style.CustomDialog);
dialog.requestWindowFeature(Window.FEATURE_NO_TITLE);
dialog.setContentView(R.layout.custom_dialog);
и ваш custom_dialog.xml должен находиться внутри вашего каталога макетов
<?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>
Если вы используете Constraint Layout, вы можете установить любой вид внутри него, чтобы заполнить процент экрана с помощью:
layout_constraintWidth_percent = "0.8"
Так, например, если у вас есть ScrollView внутри диалога, и вы хотите установить его в процентах от высоты экрана. Это было бы так:
<ScrollView
android:id="@+id/scrollView"
android:layout_width="match_parent"
android:layout_height="0dp"
app:layout_constraintHeight_percent="0.8">
Надеюсь, это поможет кому-то !!
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();
}
});