मैं एक कस्टम अलर्ट डायलॉग को ठीक से बना और प्रदर्शित कर सकता हूं, लेकिन फिर भी मेरे पास android:layout_width/height="fill_parent"डायलॉग xml में यह केवल सामग्री जितना बड़ा है।
मैं जो चाहता हूं वह डायलॉग है जो शायद 20 पिक्सेल की पैडिंग को छोड़कर पूरी स्क्रीन को भर देता है। फिर छवि जो कि संवाद का हिस्सा है, स्वचालित रूप से पूर्ण संवाद आकार में fill_parent के साथ खिंच जाएगी।
जवाबों:
इस चर्चा समूह पोस्ट में एंड्रॉइड प्लेटफ़ॉर्म डेवलपर डियान हैकॉर्न के अनुसार, डायलॉग्स ने अपने विंडो के शीर्ष स्तर की लेआउट चौड़ाई और ऊंचाई निर्धारित की 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);ध्यान दें कि विशेषताएँ डायलॉग दिखाए जाने के बाद सेट की गई हैं। जब वे सेट होते हैं, तो सिस्टम के बारे में बारीकियां होती हैं। (मुझे लगता है कि लेआउट इंजन को उन्हें पहली बार सेट करना होगा जब संवाद दिखाया गया हो, या कुछ और।)
Theme.Dialog का विस्तार करके इसे करना बेहतर होगा, फिर आपको setAttributes को कॉल करने के बारे में अनुमान लगाने का खेल नहीं खेलना होगा। (हालांकि संवाद का थोड़ा अधिक काम करना स्वचालित रूप से एक उपयुक्त प्रकाश या अंधेरे विषय या हनीकॉम्ब होलो थीम को अपनाना है। यह http://developer.android.com/guide/topics/ui/themes के अनुसार किया जा सकता है । html # SelectATheme )
RelativeLayoutइसके बजाय अपने कस्टम संवाद लेआउट को लपेटने का प्रयास करें LinearLayout। मेरे लिए यही काम किया।
डायलॉग विंडो पर FILL_PARENT निर्दिष्ट करना, जैसे अन्य लोगों ने सुझाव दिया, मेरे लिए (एंड्रॉइड 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);onCreateडिवाइस रोटेशन के बाद । इस मामले में, हम लेआउट में किसी भी चीज़ की चौड़ाई / ऊँचाई पर भरोसा नहीं कर सकते, क्योंकि यह अभी तक नहीं बनाया गया है; लेकिन डिवाइस की भौतिक चौड़ाई / ऊंचाई अभी भी उपलब्ध हैं।
ViewGroup.LayoutParams.WRAP_CONTENT तो मापदंडों में से एक के रूप में
dialog.getWindow().setLayout(LayoutParams.FILL_PARENT, LayoutParams.FILL_PARENT);FILL_PARENTवर्तमान प्रदर्शन की चौड़ाई के 90% के रूप में गणना की गई चौड़ाई के साथ स्थानापन्न कर सकते हैं । लेकिन मुझे जवाब पसंद है क्योंकि यह दूसरों की तुलना में आसान है।
यहां अन्य सभी उत्तर समझ में आते हैं, लेकिन यह नहीं मिला कि फेबियन को क्या चाहिए। यहाँ मेरा एक समाधान है। यह सही समाधान नहीं हो सकता है लेकिन यह मेरे लिए काम करता है। यह एक डायलॉग दिखाता है जो फुलस्क्रीन पर है लेकिन आप ऊपर, नीचे, बाएं या दाएं पर एक पैडिंग निर्दिष्ट कर सकते हैं।
पहले इसे अपने रेस / मान / स्टाइल में रखें। 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>जैसा कि आप देख सकते हैं कि मेरे पास Android है: paddingTop = 20dp मूल रूप से आपकी आवश्यकता है। एंड्रॉयड: windowBackground = @ रंग / Black0Percent सिर्फ एक रंग कोड मेरी color.xml पर घोषित है
res / values / color.xml
<?xml version="1.0" encoding="utf-8"?>
<resources>
<color name="Black0Percent">#00000000</color>
</resources>वह रंग कोड केवल 0% पारदर्शिता रंग के साथ डायलॉग की डिफ़ॉल्ट विंडो पृष्ठभूमि को बदलने के लिए एक डमी के रूप में कार्य करता है।
अगला कस्टम डायलॉग लेआउट रेस / लेआउट / डायलॉग। 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>अंत में यहां हमारा संवाद है जो कस्टम दृश्य सेट करता है जो हमारे डायलॉग का उपयोग करता है। 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();निष्कर्ष: मैंने कस्टमडायलॉग नाम के स्टाइल.एक्सएमएल में डायलॉग की थीम को ओवरराइड करने की कोशिश की। यह डायलॉग विंडो लेआउट को ओवरराइड करता है और मुझे एक पैडिंग सेट करने और पृष्ठभूमि की अस्पष्टता को बदलने का मौका देता है। यह सही समाधान नहीं हो सकता है, लेकिन मुझे आशा है कि यह आपकी मदद करता है .. :)
DialogFragment) पर सभी जादू जब आप करते हैं: Dialog customDialog = new Dialog(context, STYLE);धन्यवाद, वास्तव में, धन्यवाद।
आप (JUST) विंडोज़ संवाद चौड़ाई के लिए प्रतिशत का उपयोग कर सकते हैं।
होलो थीम से इस उदाहरण को देखें:
<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>आपको बस इस विषय का विस्तार करने और "मेजर" और "माइनर" के मूल्यों को 65% के बजाय 90% तक बदलने की आवश्यकता है।
सादर।
मेरे लिए निम्न कार्य ठीक है:
<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)निम्नलिखित को परिभाषित किया गया है (यूटिल्स वर्ग में सबसे अच्छा लगाया गया है):
public static int getScreenWidth(Activity activity) {
Point size = new Point();
activity.getWindowManager().getDefaultDisplay().getSize(size);
return size.x;
}डिवाइस की चौड़ाई प्राप्त करें:
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();अब तक का सबसे सरल तरीका -
यदि आपका संवाद एक लंबवत रेखीय लयआउट से बना है, तो बस एक "ऊंचाई भरने" डमी दृश्य जोड़ें, जो स्क्रीन की पूरी ऊंचाई पर कब्जा कर लेगा।
उदाहरण के लिए -
<?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"डमी देखें के गुणों में
खैर, आपको यह दिखाने के लिए अपने डायलॉग की ऊंचाई और चौड़ाई निर्धारित करनी होगी (डायलॉग।शो ())
हां, कुछ इस तरह से करें:
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: picDecorView, का अर्थ है कि गतिविधि में लेआउट ठीक से आरंभिक है अन्यथा आप उपयोग कर सकते हैं
DisplayMetrics metrics = new DisplayMetrics();
getWindowManager().getDefaultDisplay().getMetrics(metrics);
int height = metrics.heightPixels;
int wwidth = metrics.widthPixels;स्क्रीन आकार प्राप्त करने के लिए
अपने डायलॉग ऑब्जेक्ट को इनिशियलाइज़ करने के बाद और कंटेंट व्यू सेट करें। ऐसा करो और आनंद लो।
(मामले में मैं चौड़ाई के लिए ९ ०% और ऊंचाई के लिए height०% स्थापित कर रहा हूँ क्योंकि चौड़ाई ९ ०% उपकरण पट्टी से अधिक होगी)
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();मेरा उत्तर कोमा पर आधारित है, लेकिन इसे ऑनस्टार्ट को ओवरराइड करने की आवश्यकता नहीं है, लेकिन केवल ऑनक्रिएट व्यू जो कि जब आप नए टुकड़े बनाते हैं तो लगभग हमेशा डिफ़ॉल्ट रूप से ओवरराइड होता है।
@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;
}मैंने इसे एंड्रॉइड 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% (लैंडस्केप के लिए)। यह थोड़ा अधिक है कि लेखक ने पूछा लेकिन यह किसी के लिए उपयोगी हो सकता है।
आपको एक वर्ग बनाने की ज़रूरत है जो डायलॉग से निकलता है और इस कोड को अपनी onCreate(Bundle savedInstanceState)विधि में रखता है ।
संवाद की ऊंचाई के लिए कोड इसी के समान होना चाहिए।
ThemeHelper? मेरे पास यह प्रोजेक्ट उपलब्ध नहीं है।
ThemeHelperमेरी जरूरतों के लिए सिर्फ एक सहायक वर्ग है। इसकी विधि isPortrait(Context)वापस आती है कि क्या डिवाइस का स्क्रीन ओरिएंटेशन पोर्ट्रेट या लैंडस्केप है।
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;
}
}ऊपर से कई उत्तर अच्छे हैं लेकिन मेरे लिए पूरी तरह से काम नहीं किया। इसलिए मैंने @Nrr से उत्तर को जोड़ दिया और इसे प्राप्त कर लिया।
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यदि आप बाधा लेआउट का उपयोग कर रहे हैं , तो आप स्क्रीन के प्रतिशत को भरने के लिए इसके अंदर कोई भी दृश्य सेट कर सकते हैं:
layout_constraintWidth_percent = "0.8"
इसलिए, उदाहरण के लिए, यदि आपके पास संवाद के अंदर एक स्क्रॉल दृश्य है और आप इसे स्क्रीन की ऊँचाई के प्रतिशत पर सेट करना चाहते हैं। यह इस तरह होगा:
<ScrollView
android:id="@+id/scrollView"
android:layout_width="match_parent"
android:layout_height="0dp"
app:layout_constraintHeight_percent="0.8">आशा है कि यह किसी की मदद करता है !!
बस इस विषय AlertDialog दे
<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>यहाँ एक छोटा जवाब है जो मेरे लिए काम किया है (एपीआई 8 और एपीआई 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);आपको कस्टम-डायलॉग को प्रदर्शित करने के लिए एक स्टाइल @ स्टाइल.एक्सएमएल जैसे कस्टमडायलॉग का उपयोग करने की आवश्यकता है।
<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>और इस शैली का उपयोग गतिविधि.जावा में इस तरह से करें
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> 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();
}
});