DialogFragment की चौड़ाई और ऊँचाई कैसे सेट करें?


173

मैं एक xml लेआउट फ़ाइल में अपने DialogFragment के लेआउट को निर्दिष्ट करता हूं (चलो इसे कॉल करें layout_mydialogfragment.xml), और इसकी विशेषताओं layout_widthऔर layout_heightविशेष रूप से ( 100dpप्रत्येक को कहने के लिए)। मैं फिर इस लेआउट को अपने DialogFragment की onCreateView(...)विधि में निम्नानुसार फुलाता हूँ :

View view = inflater.inflate(R.layout.layout_mydialogfragment, container, false);

दुर्भाग्य से, मुझे लगता है कि जब मेरे संवाद (DialogFragment) प्रकट होता है, यह सम्मान नहीं करता है layout_widthऔर layout_heightअपने XML लेआउट फ़ाइल में निर्दिष्ट (और मेरी संवाद सिकुड़ती या variably सामग्री के आधार पर विस्तारित है)। किसी को भी पता है कि क्या या कैसे मैं अपने xml लेआउट फ़ाइल में निर्दिष्ट layout_widthऔर layout_heightनिर्दिष्ट करने के लिए अपना संवाद प्राप्त कर सकता हूं ? फिलहाल मैं अपने डायलॉगफ्रेगमेंट की onResume()विधि में अपने संवाद की चौड़ाई और ऊंचाई को फिर से निर्दिष्ट करने जा रहा हूं ...

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

... और इस प्रकार, अवांछनीय रूप से, संवाद की चौड़ाई और ऊँचाई में दो स्थानों पर भविष्य के बदलाव के लिए याद रखना होगा।


2
Jpmcosta के उत्तर को स्वीकार करने पर विचार करें। यह हैक नहीं है और यह वास्तव में समस्या को ठीक करता है।
बोगदान जुरैक

जवाबों:


168

यदि आप संसाधन मूल्यों से सीधे रूपांतरित होते हैं:

int width = getResources().getDimensionPixelSize(R.dimen.popup_width);
int height = getResources().getDimensionPixelSize(R.dimen.popup_height);        
getDialog().getWindow().setLayout(width, height);

फिर डायलॉग के लिए अपने लेआउट में match_parent निर्दिष्ट करें:

android:layout_width="match_parent"
android:layout_height="match_parent"

आपको केवल एक जगह की चिंता करनी होगी (इसे अपने स्थान पर रखें DialogFragment#onResume)। यह सही नहीं है, लेकिन कम से कम यह आपके संवाद के लेआउट फ़ाइल के मूल के रूप में एक RelativeLayout होने के लिए काम करता है।


3
यह उत्तर मेरे मामले में (DialogFragment के लिए) काम नहीं करता है। मुझे विंडो दिखाने के परिवर्तन आकार के लिए FragmentLayout params का उपयोग करना था।
रसफियरथ

3
मुझे अपना लेआउट लपेटना पड़ा RelativeLayoutऔर इससे मुझे मदद मिली। समाधान के लिए बहुत धन्यवाद - इसने मुझे बहुत समय बचाया।
जॉनी डो

62
यह मेरे लिए बहुत अच्छा काम करता है (एंड्रॉइड 4.0+), एक बार मुझे एहसास हुआ कि इसमें होना चाहिए onResume(), नहीं onCreateView()। (मेरा रूट लेआउट RelativeLayout एक स्क्रॉल दृश्य में लपेटा गया है।)
जोनिक

14
कुछ मामलों में उपयोगी: पूरे स्क्रीन की चौड़ाई का उपयोग करें:int width = getResources().getDisplayMetrics().widthPixels
जोनिक

6
जोनीक के लिए +1। -1 रिचर्ड के लिए। मैं हमेशा समर्थन अंशों का उपयोग करता हूं और काम करने के लिए इसे प्राप्त करने में कभी सक्षम नहीं रहा हूं onCreateDialog()। में होना चाहिए onResume()
मिंसमैन

146

मैंने Fragment.onResume()अंतर्निहित डायलॉग से विशेषताओं को ओवरराइड करना और हथियाना समाप्त कर दिया , फिर वहां चौड़ाई / ऊँचाई को निर्धारित किया। मैंने सबसे बाहरी लेआउट ऊंचाई / चौड़ाई निर्धारित की है match_parent। ध्यान दें कि यह कोड xml लेआउट में परिभाषित मार्जिन का भी सम्मान करता है।

@Override
public void onResume() {
    super.onResume();
    ViewGroup.LayoutParams params = getDialog().getWindow().getAttributes();
    params.width = LayoutParams.MATCH_PARENT;
    params.height = LayoutParams.MATCH_PARENT;
    getDialog().getWindow().setAttributes((android.view.WindowManager.LayoutParams) params);
}

2
धन्यवाद ! इससे मेरा काम बनता है ! इसके अलावा यह करने के लिए एक सुंदर तरीका है।
एंटोनीप

1
@jmaculate - क्विक क्वेश्चन: जब आप के लिए कास्टिंग कर रहे हैं (android.view.WindowManager.LayoutParams), तो आप इसे किस से कास्टिंग कर रहे हैं? LayoutParamsफ़ंक्शन की पहली 3 पंक्तियों में प्रदर्शित होने के लिए सही आयात का चयन करते समय मैं हैरान था । चुनकर समाप्त किया (android.view.WindowManager.LayoutParams)। क्या यह सही माना जाता है?
देव-आईएल

@ Dev-iL getAttributes () एक WindowManger.LayoutParams लौटाता है, लेकिन मेरे मामले में मैंने इसे कथित रूप से ViewGroup.LayoutParams में डाल दिया है, क्योंकि मुझे इसकी ज़रूरत है (प्रभावी जावा, आइटम 52 - मैं इसे प्रतिबिंबित करने के लिए प्रश्न संपादित
करूंगा

1
यदि आपको इसे फिर से डालने की आवश्यकता है android.view.WindowManager.LayoutParams, तो ViewGroup.LayoutParamsऊपर की तीन पंक्तियों का उपयोग करना बेकार है ... आप यहां कोई लचीलापन हासिल नहीं करते हैं। जो भी हो, इस अच्छे उत्तर के लिए धन्यवाद!
केविन रॉबेल

2
यह सबसे अच्छा उपाय है। आप MATCH_PARENT या WRAP_CONTENT के साथ पिक्सेल के एक विशिष्ट मूल्य का भी उपयोग कर सकते हैं।
कोएश

98

मुझे एक्सएमएल मुख्य लेआउट में निम्नलिखित को परिभाषित करने वाला एक निश्चित आकार का डायलॉगफ्रेगमेंट मिला (मेरे मामले में रैखिकरण):

android:layout_width="match_parent"
android:layout_height="match_parent"
android:minWidth="1000dp"
android:minHeight="450dp"

4
मैंने पाया कि मुझे हनीकॉम्ब में मिडविथ और मिनहाइट की जरूरत थी - लेकिन आईसीएस में नहीं।
daveywc

1
यह पहली नज़र में काम करता प्रतीत होता है लेकिन इसे शायद टाला जाना चाहिए। डिवाइस की चौड़ाई के आधार पर दृश्य स्क्रीन बंद रहेगा, यदि आपके निचले दाएं कोने में बटन हैं तो वे दिखाई नहीं देंगे।
कोडिएन्गल

दृश्य स्क्रीन से जारी नहीं है। एंड्रॉइड सिस्टम यह सुनिश्चित करने के लिए लगता है कि डायलॉगफ्रैगमेंट दृश्य सीमा के अंदर रहता है (एक छोटे से मार्जिन के साथ), भले ही ये सीमाएं निर्दिष्ट मिनीवेट और मिनीहाइट से छोटी हों।
लेंसफ्लेर 9

51

केवल एक चीज जो मेरे मामले में काम करती थी, वह थी जिसका समाधान यहाँ बताया गया है: http://adilatwork.blogspot.mx/2012/11/android-dialogfragment-dialog-sizing.html

आदिल ब्लॉग पोस्ट से स्निपेट:

@Override
public void onStart()
{
  super.onStart();

  // safety check
  if (getDialog() == null)
    return;

  int dialogWidth = ... // specify a value here
  int dialogHeight = ... // specify a value here

  getDialog().getWindow().setLayout(dialogWidth, dialogHeight);

  // ... other stuff you want to do in your onStart() method
}

सही समाधान और ब्लॉग में बहुत अच्छी तरह से समझाया गया है।
वरुण भारद्वाज

+1 getDialog().getWindow().setLayout(dialogWidth, dialogHeight); एक DialogFragment के लिए पूरी तरह से काम करता है। लेकिन मुझे सुरक्षा जांच की समझ नहीं है। हमें जाँच क्यों करनी है null?
tpk

3
@ 2943 - केवल इसलिए कि इस बात की कोई गारंटी नहीं है कि Dialog(का एक बच्चा DialogFragment) उस समय उपलब्ध होगा जब यह अनुरोध किया जाता है। यह संभव है कि जब हम कॉल करेंगे तो एंड्रॉइड अशक्त हो जाएगा getDialog()
रमीराबेल

@mirabelle यदि आप संवाद के ऑनस्टार्ट कॉलबैक के साथ हैं तो संवाद कैसे अशक्त हो सकता है?
रोममेक्स

49

अपनी DialogFragmentचौड़ाई और ऊंचाई को नियंत्रित करने का एक तरीका यह है कि यह सुनिश्चित करें कि इसका संवाद आपके दृश्य की चौड़ाई और ऊंचाई का सम्मान करता है यदि उनका मूल्य है WRAP_CONTENT

का उपयोग करते हुए ThemeOverlay.AppCompat.Dialog

इसे प्राप्त करने का एक सरल तरीका यह है ThemeOverlay.AppCompat.Dialogकि एंड्रॉइड सपोर्ट लाइब्रेरी में शामिल शैली का उपयोग किया जाए ।

DialogFragmentसाथ Dialog:

@NonNull
@Override
public Dialog onCreateDialog(Bundle savedInstanceState) {
    LayoutInflater inflater = LayoutInflater.from(getContext());
    View view = inflater.inflate(R.layout.dialog_view, null);

    Dialog dialog = new Dialog(getContext(), R.style.ThemeOverlay_AppCompat_Dialog);
    dialog.setContentView(view);
    return dialog;
}

DialogFragmentके साथ AlertDialog(चेतावनी:) minHeight="48dp":

@NonNull
@Override
public Dialog onCreateDialog(Bundle savedInstanceState) {
    LayoutInflater inflater = LayoutInflater.from(getContext());
    View view = inflater.inflate(R.layout.dialog_view, null);

    AlertDialog.Builder builder = new AlertDialog.Builder(getContext(), R.style.ThemeOverlay_AppCompat_Dialog);
    builder.setView(view);
    return builder.create();
}

आप ThemeOverlay.AppCompat.Dialogअपने ऐप के xml थीम में जोड़कर, अपने संवाद बनाते समय डिफ़ॉल्ट थीम के रूप में भी सेट कर सकते हैं ।
सावधान रहें, क्योंकि कई संवादों को अच्छा दिखने के लिए डिफ़ॉल्ट न्यूनतम चौड़ाई की आवश्यकता होती है।

<!-- Base application theme. -->
<style name="AppTheme" parent="Theme.AppCompat.Light.DarkActionBar">
    <!-- For Android Dialog. -->
    <item name="android:dialogTheme">@style/ThemeOverlay.AppCompat.Dialog</item>

    <!-- For Android AlertDialog. -->
    <item name="android:alertDialogTheme">@style/ThemeOverlay.AppCompat.Dialog</item>

    <!-- For AppCompat AlertDialog. -->
    <item name="alertDialogTheme">@style/ThemeOverlay.AppCompat.Dialog</item>

    <!-- Other attributes. -->
</style>

DialogFragmentके साथ Dialog, का उपयोग कर android:dialogTheme:

@NonNull
@Override
public Dialog onCreateDialog(Bundle savedInstanceState) {
    LayoutInflater inflater = LayoutInflater.from(getContext());
    View view = inflater.inflate(R.layout.dialog_view, null);

    Dialog dialog = new Dialog(getContext());
    dialog.setContentView(view);
    return dialog;
}

DialogFragmentके साथ AlertDialog, android:alertDialogThemeया का उपयोग कर alertDialogTheme(चेतावनी:) minHeight="48dp":

@NonNull
@Override
public Dialog onCreateDialog(Bundle savedInstanceState) {
    LayoutInflater inflater = LayoutInflater.from(getContext());
    View view = inflater.inflate(R.layout.dialog_view, null);

    AlertDialog.Builder builder = new AlertDialog.Builder(getContext());
    builder.setView(view);
    return builder.create();
}

बक्शीश

पुराने Android API पर, Dialogउनके शीर्षक (भले ही आप एक सेट न करें) के कारण कुछ चौड़ाई के मुद्दे हैं।
यदि आप ThemeOverlay.AppCompat.Dialogशैली का उपयोग नहीं करना चाहते हैं और आपको Dialogशीर्षक की आवश्यकता नहीं है (या कोई कस्टम है), तो आप इसे अक्षम करना चाहते हैं:

@NonNull
@Override
public Dialog onCreateDialog(Bundle savedInstanceState) {
    LayoutInflater inflater = LayoutInflater.from(getContext());
    View view = inflater.inflate(R.layout.dialog_view, null);

    Dialog dialog = new Dialog(getContext());
    dialog.requestWindowFeature(Window.FEATURE_NO_TITLE);
    dialog.setContentView(view);
    return dialog;
}

आउटडेटेड उत्तर, ज्यादातर मामलों में काम नहीं करेगा

मैं निश्चित रूप से एक निश्चित आकार को निर्दिष्ट किए बिना संवाद को अपने लेआउट की चौड़ाई और ऊंचाई का सम्मान करने की कोशिश कर रहा था।

मुझे लगा कि android:windowMinWidthMinorऔर android:windowMinWidthMajorसमस्या पैदा कर रहे हैं। भले ही वे मेरे Activityया के विषय में शामिल नहीं थे Dialog, फिर भी वे Activityकिसी भी तरह से थीम पर लागू हो रहे थे ।

मैं तीन संभावित समाधानों के साथ आया हूं।

समाधान 1: एक कस्टम डायलॉग थीम बनाएँ और डायलॉग बनाते समय इसका उपयोग करें DialogFragment

<style name="Theme.Material.Light.Dialog.NoMinWidth" parent="android:Theme.Material.Light.Dialog">
    <item name="android:windowMinWidthMinor">0dip</item>
    <item name="android:windowMinWidthMajor">0dip</item>
</style>
@Override
public Dialog onCreateDialog(Bundle savedInstanceState) {
    return new Dialog(getActivity(), R.style.Theme_Material_Light_Dialog_NoMinWidth);
}

समाधान 2: एक कस्टम थीम बनाएं जिसका उपयोग संवाद के लिए किया ContextThemeWrapperजाएगा Context। यदि आप कस्टम डायलॉग थीम नहीं बनाना चाहते हैं (उदाहरण के लिए, जब आप द्वारा निर्दिष्ट विषय का उपयोग करना चाहते हैं) तो इसका उपयोग करें android:dialogTheme

<style name="Theme.Window.NoMinWidth" parent="">
    <item name="android:windowMinWidthMinor">0dip</item>
    <item name="android:windowMinWidthMajor">0dip</item>
</style>
@Override
public Dialog onCreateDialog(Bundle savedInstanceState) {
    return new Dialog(new ContextThemeWrapper(getActivity(), R.style.Theme_Window_NoMinWidth), getTheme());
}

समाधान 3 (AlertDialog) के साथ : लागू करें android:windowMinWidthMinorऔर द्वारा बनाए गए में ।android:windowMinWidthMajorContextThemeWrapperAlertDialog$Builder

<style name="Theme.Window.NoMinWidth" parent="">
    <item name="android:windowMinWidthMinor">0dip</item>
    <item name="android:windowMinWidthMajor">0dip</item>
</style>
@Override
public final Dialog onCreateDialog(Bundle savedInstanceState) {
    View view = new View(); // Inflate your view here.
    AlertDialog.Builder builder = new AlertDialog.Builder(getActivity());
    builder.setView(view);
    // Make sure the dialog width works as WRAP_CONTENT.
    builder.getContext().getTheme().applyStyle(R.style.Theme_Window_NoMinWidth, true);
    return builder.create();
}

4
मैं सच में नहीं जानता कि क्यों नरक यह स्वीकार किए जाते हैं जवाब नहीं है। यह वस्तुतः एकमात्र उत्तर है जो काम करता है और एक हैक नहीं है (मैं ज्यादातर आपके 1 समाधान के लिए बात कर रहा हूं)।
बोगदान जुरैक

1
दुर्भाग्य से यह केवल एक घंटे खर्च करने के बाद पाया कि कैसे हल करना है!
ब्रेनविजन

समाधान 3 मेरे जीवन को बचाता है। बहुत बहुत धन्यवाद
शमौन

मैं पुराने Android API पर आपकी समस्या को पुन: उत्पन्न करने में सक्षम था। कुछ विकल्प जोड़े जो आपकी मदद कर सकते हैं।
jpmcosta

समाधान 1 ने मेरे लिए काम किया। मैं सिर्फ Theme.MaterialComponents.Light.Dialogमाता-पिता के रूप में इस्तेमाल किया और के निर्माण में इस शैली का इस्तेमाल किया MaterialAlertDialogBuilder। 1 घंटे के शोध के बाद आपके जवाब पर ठोकर खाई। धन्यवाद और अंगूठा।
शैडल उल हसन

39

गोत्र # 13: DialogFragmentलेआउट

यह वास्तव में मन सुन्न करने वाला है।

एक बनाते समय DialogFragment, आप ओवरराइड करना चुन सकते हैं onCreateView(जो ViewGroupआपके .xml लेआउट को संलग्न करने के लिए) या onCreateDialog, जो नहीं करता है।

आपको दोनों विधियों को ओवरराइड नहीं करना चाहिए, क्योंकि आप बहुत संभावना है कि जब तक या जब आपके संवाद का लेआउट फुलाया गया था, तब तक एंड्रॉइड को भ्रमित करेगा! WTF?

ओवरराइड करने का विकल्प OnCreateDialogया इस OnCreateViewबात पर निर्भर करता है कि आप संवाद का उपयोग कैसे करना चाहते हैं।

  • यदि आप संवाद को एक विंडो (सामान्य व्यवहार) में लॉन्च करेंगे, तो आपको ओवरराइड करने की उम्मीद है OnCreateDialog
  • यदि आप मौजूदा UI लेआउट (FAR कम सामान्य) के भीतर संवाद टुकड़ा एम्बेड करने का इरादा रखते हैं, तो आपको ओवरराइड करने की उम्मीद है OnCreateView

यह संभवतः दुनिया की सबसे बुरी चीज है।

onCreateDialog पागलपन

इसलिए, आप विंडो में प्रदर्शित करने के लिए एक स्वनिर्धारित उदाहरण बनाने के लिए onCreateDialogअपने ओवरराइड कर रहे हैं। ठंडा। लेकिन याद रखें, नहीं प्राप्त करता हैDialogFragmentAlertDialogonCreateDialogViewGroup अपने कस्टम .xml लेआउट को संलग्न करने के लिए है । कोई बात नहीं, आप बस nullइस inflateविधि को पास करें ।

पागलपन शुरू होने दो।

जब आप ओवरराइड करते हैं onCreateDialog, तो Android COMPLETELY IGNORES आपके द्वारा फुलाए जाने वाले .xml लेआउट के रूट नोड की कई विशेषताएँ। इसमें शामिल है, लेकिन संभवतः इसके लिए सीमित नहीं है:

  • background_color
  • layout_gravity
  • layout_width
  • layout_height

यह लगभग हास्यप्रद है, जैसा कि आपको सेट करने के लिए आवश्यक है layout_width और layout_heightहर .xml लेआउट या एंड्रॉयड स्टूडियो का एक अच्छा शर्म की बात है की छोटे लाल बैज के साथ तमाचा होगा।

सिर्फ शब्द DialogFragment मुझे puke करना चाहता है। मैं एंड्रॉइड गोच और स्नफ़स से भरा एक उपन्यास लिख सकता था, लेकिन यह सबसे अंदर से एक है।

पवित्रता की ओर लौटने के लिए, सबसे पहले, हम JUST को बहाल करने के लिए एक शैली की घोषणा करते हैं background_colorऔर layout_gravityहम उम्मीद करते हैं:

<style name="MyAlertDialog" parent="Theme.AppCompat.Dialog">
    <item name="android:windowBackground">@android:color/transparent</item>
    <item name="android:layout_gravity">center</item>
</style>

ऊपर की शैली संवाद के लिए आधार विषय से विरासत में मिली है (में AppCompat इस उदाहरण में विषय में)।

इसके बाद, हम स्टाइल को लागू करते हैं , जो कि एंड्रॉइड के मूल्यों को वापस लाने के लिए, मानक AlertDialogरूप से देखने और महसूस को बहाल करने के लिए प्रोग्रामेटिक रूप से लागू होता है:

public class MyDialog extends DialogFragment {
    @Override
    public Dialog onCreateDialog(Bundle savedInstanceState) {
        View layout = getActivity().getLayoutInflater().inflate(R.layout.my_dialog_layout, null, false);
        assert layout != null;
        //build the alert dialog child of this fragment
        AlertDialog.Builder b = new AlertDialog.Builder(getActivity());
        //restore the background_color and layout_gravity that Android strips
        b.getContext().getTheme().applyStyle(R.style.MyAlertDialog, true);
        b.setView(layout);
        return b.create();
    }
}

उपरोक्त कोड आपका बना देगा AlertDialog लुक को AlertDialogफिर से एक जैसा । शायद यह काफी अच्छा है।

लेकिन रुकिए, और भी है!

यदि आप एक विनिर्देशन सेट करना चाहते हैं layout_widthया layout_heightआपके लिएAlertDialog जब यह दिखाया गया है (बहुत संभावना है), तो अनुमान लगाएं कि आपने अभी क्या नहीं किया है!

प्रफुल्लितता जारी है जैसा कि आप महसूस करते हैं कि यदि आप एक विशिष्ट layout_widthया layout_heightअपने फैंसी नई शैली में सेट करने का प्रयास करते हैं, तो एंड्रॉइड पूरी तरह से अनदेखा कर देगा, भी:!

<style name="MyAlertDialog" parent="Theme.AppCompat.Dialog">
    <item name="android:windowBackground">@android:color/transparent</item>
    <item name="android:layout_gravity">center</item>
    <!-- NOPE!!!!! --->
    <item name="android:layout_width">200dp</item>
    <!-- NOPE!!!!! --->
    <item name="android:layout_height">200dp</item>
</style>

एक विशिष्ट विंडो की चौड़ाई या ऊँचाई निर्धारित करने के लिए, आप एक पूरी 'पोषण विधि' पर जाएँगे और उससे निपटेंगे LayoutParams:

@Override
public void onResume() {
    super.onResume();
    Window window = getDialog().getWindow();
    if(window == null) return;
    WindowManager.LayoutParams params = window.getAttributes();
    params.width = 400;
    params.height = 400;
    window.setAttributes(params);
}

कई लोग एंड्रॉइड के खराब उदाहरण का अनुसरण WindowManager.LayoutParamsकरते हुए अधिक सामान्य तक का अनुसरण करते हैं ViewGroup.LayoutParams, केवल सही तरीके से घूमने के लिए और बाद में कुछ लाइनों के ViewGroup.LayoutParamsलिए नीचे डाली जाती हैं WindowManager.LayoutParams। प्रभावी जावा को धिक्कार है, कि अनावश्यक कास्टिंग कोड को डिक्रिप्ट करने के लिए कठिन बनाने के अलावा अन्य कुछ भी नहीं प्रदान करता है।

साइड नोट: LayoutParamsएंड्रॉइड एसडीके के पार कुछ दोहराव हैं - मौलिक रूप से खराब डिजाइन का एक आदर्श उदाहरण।

संक्षेप में

के लिए DialogFragmentकि ओवरराइड है onCreateDialog:

  • मानक AlertDialogलुक और फील को रिस्टोर करने के लिए , ऐसा स्टाइल बनाएं जो background_color= transparentऔर layout_gravity= सेट करें centerऔर उस स्टाइल को अंदर लागू करें onCreateDialog
  • एक विशिष्ट layout_widthऔर / या सेट करने के लिए layout_height, इसे प्रोग्रामेटिक रूप से onResumeसाथ में करेंLayoutParams
  • पवित्रता बनाए रखने के लिए, एंड्रॉइड एसडीके के बारे में सोचने की कोशिश न करें।

13
इस जवाब को पढ़कर मुझे रोना आता है।
बेसिनेटर

3
यार, आपने ठीक वही वर्णन किया है जो मैं अभी अनुभव कर रहा हूं।
मर्ट गुल्सोइ

2
Android बकवास है। समझता हूँ भाई। सब कुछ के लिए एक संदर्भ की आवश्यकता है, ऐप प्रक्रिया को मारता है, कुछ चीजों के लिए समर्थन पुस्तकालयों की कमी है, सूची चलती है
डेनिसवा

1
@rmirabelle - यह उत्तर वास्तव में मदद करता है, आप वास्तव में एक मध्यम ब्लॉग लिख सकते हैं, और कई के लिए मददगार हो सकते हैं। मेरे मामले में मैं बाधा लेआउट और DialogFragment का उपयोग कर रहा हूं, इसलिए Android 9 में उपेक्षा की गई, Android 9 के नीचे यह ठीक काम कर रहा है। मैंने जोड़ा है - "android: windowMinWidthMajor," android: windowMinWidthMinor "स्टाइल में है और यह ठीक काम करने लगा है।
राहुल


14

जब मुझे डायलॉगग्रैगमेंट को थोड़ा व्यापक बनाने की आवश्यकता होती है, तो मैं मिनीवार्ड सेट कर रहा हूं:

<LinearLayout
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:minWidth="320dp"
    ... />

1
मेरी राय में सबसे अच्छा समाधान!
फेबियन कन्नप

क्या होगा अगर आप इसे संकरा बनाना चाहते हैं?
डैनियल

8

ओवरराइड करने के लिए मैं एक बाध्यकारी कारण नहीं दिख रहा है onResumeया onStartचौड़ाई और ऊंचाई सेट करने के लिए Windowअंदर DialogFragmentकीDialog - इन विशेष जीवन चक्र के तरीकों को बार-बार और अनावश्यक रूप से कहा जाता है प्राप्त कर सकते हैं निष्पादित कि बहु खिड़की स्विचिंग जैसी चीजों की वजह से कोड एक बार से अधिक आकार बदलने, backgrounding फिर ऐप को फोरग्राउंड करना, और इसी तरह। उस पुनरावृत्ति के परिणाम काफी तुच्छ हैं, लेकिन उसके लिए समझौता क्यों करें?

एक ओवरराइड onActivityCreated()विधि के बजाय चौड़ाई / ऊँचाई सेट करना एक सुधार होगा क्योंकि यह विधि वास्तविक रूप से केवल एक बार आपके उदाहरण के अनुसार कहलाती है DialogFragment। उदाहरण के लिए:

@Override
public void onActivityCreated(Bundle savedInstanceState) {
    super.onActivityCreated(savedInstanceState);

    Window window = getDialog().getWindow();
    assert window != null;

    WindowManager.LayoutParams layoutParams = window.getAttributes();
    layoutParams.width = ViewGroup.LayoutParams.MATCH_PARENT;
    window.setAttributes(layoutParams);
}

ऊपर मैंने केवल match_parentउपकरण अभिविन्यास के बावजूद चौड़ाई निर्धारित की है । यदि आप चाहते हैं कि आपका लैंडस्केप डायलॉग इतना व्यापक न हो, तो आप getResources().getConfiguration().orientation == Configuration.ORIENTATION_PORTRAITपहले से चेक कर सकते हैं ।


6

सबसे बाहरी लेआउट में आयाम संवाद में काम नहीं करता है। आप एक लेआउट जोड़ सकते हैं जहां बाहरी के नीचे आयाम सेट करें।

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="wrap_content"
android:layout_height="wrap_content">

<LinearLayout
    android:layout_width="xxdp"
    android:layout_height="xxdp"
    android:orientation="vertical">

</LinearLayout>


5

मैंने इसे रूट एलिमेंट लेआउट पैरामीटर सेट करते हुए तय किया।

int width = activity.getResources().getDisplayMetrics().widthPixels;
int height = activity.getResources().getDisplayMetrics().heightPixels;
content.setLayoutParams(new LinearLayout.LayoutParams(width, height));

5

यहाँ एक तरीका है DialogFragment चौड़ाई / ऊंचाई xml में सेट करने के लिए। बस एक पारदर्शी पृष्ठभूमि के साथ एक Framelayout (किसी भी लेआउट काम करेगा) में अपने दृश्यहियरार्की को लपेटें।

एक पारदर्शी पृष्ठभूमि एक विशेष ध्वज लगती है, क्योंकि यह स्वचालित रूप से फ्रेमलैट के बच्चे को खिड़की में केंद्रित करता है जब आप ऐसा करते हैं। आप अभी भी अपने टुकड़े के पीछे पूरी स्क्रीन को काला कर पाएंगे, यह दर्शाता है कि आपका टुकड़ा सक्रिय तत्व है।

<?xml version="1.0" encoding="utf-8"?>
<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:background="@color/transparent">

    <RelativeLayout
        android:layout_width="match_parent"
        android:layout_height="300dp"
        android:background="@color/background_material_light">

      .....

मैं इसे एक कोशिश देने जा रहा हूं क्योंकि अगर यह लगातार काम करता है, तो यह XML में लेआउट के कोडिंग कोड में इसका सबसे बेहतर तरीका है और कोड में है। धन्यवाद
रमीराबेल

मुझे इस दृष्टिकोण का विचार पसंद है, लेकिन जब परीक्षण किया जाता है, तो यह केवल प्रोग्राम ऊंचाई और चौड़ाई बदलने की तुलना में एक अलग लेआउट देता है। उदाहरण के लिए, कुल चौड़ाई जबरन एलर्टडायलॉग द्वारा वहन की गई अधिकतम चौड़ाई तक कम हो जाती है (संभवतः एंड्रॉइड शैलियों के कारण)। जब मैं सिर्फ w और h को कोड के माध्यम से सेट करता हूं, तो AlertDialog स्टाइल ओवरराइड हो जाता है। यह हालांकि कई जरूरतों को फिट कर सकता है और एक अच्छा विचार है। इतिहास में सबसे खराब एसडीके रहते हैं।
रमीराबेल

OnCreateView के लिए बहुत अच्छा काम किया, जब तक कि मैं आंतरिक चौड़ाई को match_parent में बदलना नहीं चाहता था ...
tudor

5

यहाँ kotlin संस्करण है

    override fun onResume() {
        super.onResume()

        val params:ViewGroup.LayoutParams = dialog.window.attributes
        params.width = LinearLayout.LayoutParams.MATCH_PARENT
        params.height = LinearLayout.LayoutParams.MATCH_PARENT
        dialog.window.attributes = params as android.view.WindowManager.LayoutParams
    }

4

आप चौड़ाई के लिए प्रतिशत का उपयोग कर सकते हैं।

<style name="Theme.Holo.Dialog.MinWidth">
<item name="android:windowMinWidthMajor">70%</item>

मैंने इस उदाहरण के लिए होलो थीम का उपयोग किया।


3

आप जावा से लेआउट की चौड़ाई और ऊंचाई निर्धारित करने के लिए कोड से नीचे कर सकते हैं।

final AlertDialog alertDialog  = alertDialogBuilder.create();
final WindowManager.LayoutParams WMLP = alertDialog.getWindow().getAttributes();

WMLP.gravity = Gravity.TOP;
WMLP.y = mActionBarHeight;
WMLP.x = getResources().getDimensionPixelSize(R.dimen.unknown_image_width);

alertDialog.getWindow().setAttributes(WMLP);
alertDialog.show();

2

मैं AlertDialog.Builder का उपयोग करके संवाद बनाता हूं इसलिए मैंने एक ऑनशॉलिस्टनर के अंदर रॉड्रिगो के उत्तर का उपयोग किया।

dialog.setOnShowListener(new OnShowListener() {

            @Override
            public void onShow(DialogInterface dialogInterface) {
                Display display = getWindowManager().getDefaultDisplay();
                DisplayMetrics outMetrics = new DisplayMetrics ();
                display.getMetrics(outMetrics);
                dialog.getWindow().setLayout((int)(312 * outMetrics.density), (int)(436 * outMetrics.density));
            }

        });

(मुख्य रूप से भविष्य के पाठकों के लिए :) stackoverflow.com/a/7979823/3372061 में Snicolas" DialogFragmentबनाम AlertDialog" की चर्चा द्वारा टिप्पणी देखें ।
देव-आईएल

2

एंड्रॉइड 6.0 पर काम करना, उसी मुद्दे में भाग गया। कस्टम दृश्य के रूट में वास्तविक सेट की परवाह किए बिना थीम में AlertDialogपूर्वनिर्धारित widthसेट के लिए डिफ़ॉल्ट होगा । मैं इसे ठीक से समायोजित करने के स्थापित करने के लिए प्राप्त करने में सक्षम था की । आगे की जांच के बिना, ऐसा लगता है कि वास्तविक तत्वों को आकार देना और उनके आसपास जड़ लपेटने से यह उम्मीद के मुताबिक काम करता है। नीचे एक लोडिंग संवाद का XML लेआउट है जो संवाद को सही ढंग से सेट करता है। इस पुस्तकालय का उपयोग करनाwidthLayoutwidthloading_message TextViewLayoutwidthएनीमेशन के लिए ।

<RelativeLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:background="@color/custom_color"
    android:padding="@dimen/custom_dimen">
    <com.github.rahatarmanahmed.cpv.CircularProgressView
        xmlns:app="http://schemas.android.com/apk/res-auto"
        android:id="@+id/progress_view"
        android:layout_width="40dp"
        android:layout_height="40dp"
        android:layout_centerHorizontal="true"
        app:cpv_color="@color/white"
        app:cpv_animAutostart="true"
        app:cpv_indeterminate="true" />
    <TextView
        android:id="@+id/loading_message"
        android:layout_width="100dp"
        android:layout_height="wrap_content"
        android:layout_below="@+id/progress_view"
        android:layout_centerHorizontal="true"
        android:gravity="center"
        android:textSize="18dp"
        android:layout_marginTop="@dimen/custom_dimen"
        android:textColor="@color/white"
        android:text="@string/custom_string"/>
</RelativeLayout>

2

आसान और ठोस:

@Override
    public void onResume() {
        // Sets the height and the width of the DialogFragment
        int width = ConstraintLayout.LayoutParams.MATCH_PARENT;
        int height = ConstraintLayout.LayoutParams.MATCH_PARENT;
        getDialog().getWindow().setLayout(width, height);

        super.onResume();
    }

2

मेरे मामले में DialogFragmentएक की तरह पूर्ण गतिविधि आकार पर कब्जा कर लिया FragmentDialogFragmentएक्सएमएल-लेआउट के आधार पर किया गया था, नहीं AlertDialog। मेरी गलती संवाद के टुकड़े को FragmentManagerएक सामान्य टुकड़े के रूप में जोड़ रही थी :

fragmentManager?.beginTransaction()?.run {
    replace(R.id.container, MyDialogFragment.newInstance(), MyDialogFragment.TAG)
    addToBackStack(MyDialogFragment.TAG)
}?.commitAllowingStateLoss()

इसके बजाय मुझे showसंवाद खंड की आवश्यकता है :

val dialogFragment = MyDialogFragment.newInstance()
fragmentManager?.let { dialogFragment.show(it, MyDialogFragment.TAG) }

कुछ संपादन (मैं ViewPager2लेआउट में है) के बाद संवाद टुकड़ा बहुत संकीर्ण हो गया:

यहां छवि विवरण दर्ज करें

मैंने N1hk के समाधान का उपयोग किया :

override fun onActivityCreated(savedInstanceState: Bundle?) {
    super.onActivityCreated(savedInstanceState)

    dialog?.window?.attributes?.width = ViewGroup.LayoutParams.MATCH_PARENT
}

अब इसमें चौड़ाई और ऊंचाई को परिभाषित किया गया है, न कि पूर्ण गतिविधि आकार को।

मैं इसके बारे में onCreateViewऔर कहना चाहता हूं onCreateDialog। यदि आपके पास लेआउट पर आधारित एक संवाद टुकड़ा है, तो आप इन 2 विधियों में से किसी का उपयोग कर सकते हैं।

1) यदि आप उपयोग करते हैं onCreateView, तो आपको onActivityCreatedचौड़ाई सेट करने के लिए उपयोग करना चाहिए ।

2) यदि आप onCreateDialogइसके बजाय उपयोग करते हैं onCreateView, तो आप वहां पैरामीटर सेट कर सकते हैं। onActivityCreatedजरूरत नहीं होगी।

override fun onCreateDialog(savedInstanceState: Bundle?): Dialog {
    super.onCreateDialog(savedInstanceState)

    val view = activity?.layoutInflater?.inflate(R.layout.your_layout, null)

    val dialogBuilder = MaterialAlertDialogBuilder(context!!).apply { // Or AlertDialog.Builder(context!!).apply
        setView(view)
        // setCancelable(false)
    }

    view.text_view.text = "Some text"

    val dialog = dialogBuilder.create()
    // You can access dialog.window here, if needed.

    return dialog
}

आपने मेरा दिन बचाया, onActivity में चौड़ाई स्थापित करते हुए मेरे लिए काम किया।
हैगर मैगी

@ManishKumarSharma, शुभकामनाएँ!
कूलमाइंड

1

मेरे मामले में यह align_parentBottom="true"एक के अंदर एक दृश्य के कारण दिया गया था RelativeLayout। सभी alignParentBottom को हटा दिया और सभी लेआउट को लंबवत LinearLayouts में बदल दिया और समस्या चली गई।


1

कस्टम संवाद लेआउट के मूल लेआउट को RelativeLayout पर सेट करें , स्वचालित रूप से सामान्य चौड़ाई और ऊंचाई प्राप्त करें।

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:layout_height="match_parent">

इसने मेरे लिए काम किया। मैं अपने डायलॉग में कंट्रोल्स को बाहर करने के लिए एक कॉन्ट्राट्राइटलआउट का इस्तेमाल करना चाहता था, इसलिए मैंने रूट लेआउट के लिए एक रिलेटिवलैटआउट का इस्तेमाल किया और फिर सीधे कॉन्ट्राटाइटलआउट को इसके अंदर डाल दिया। इससे मुझे सामान्य आकार का संवाद मिला। जब मैंने कॉन्स्ट्रेण्टलैट को रूट के रूप में कुछ और बदले बिना लगाया तो डायलॉग चौड़ाई बहुत व्यापक नहीं हुई!
लीफकटर

1

पहले के समाधानों में से एक ने लगभग काम किया। मैंने कुछ अलग करने की कोशिश की और यह मेरे लिए काम करना खत्म कर दिया।

(सुनिश्चित करें कि आप उसके समाधान को देखें) यह उसका समाधान था .. यहाँ क्लिक करें इसके अलावा काम किया: buildder.getConxt ()। GetTheme ()। ApplyStyle (R.style.Theme_Window_NowMinWidth, true);

मैंने इसे बदल दिया

 @Override
    public Dialog onCreateDialog(Bundle savedInstanceState) {


        // Use the Builder class for convenient dialog construction
        AlertDialog.Builder builder = new AlertDialog.Builder(getActivity());

        // Get layout inflater
        LayoutInflater layoutInflater = getActivity().getLayoutInflater();

        // Set layout by setting view that is returned from inflating the XML layout
        builder.setView(layoutInflater.inflate(R.layout.dialog_window_layout, null));


        AlertDialog dialog = builder.create();

        dialog.getContext().setTheme(R.style.Theme_Window_NoMinWidth);

अंतिम पंक्ति व्हाट्स अलग है।


0
@Override
public void onStart() {
    super.onStart();
    Dialog dialog = getDialog();
    if (dialog != null)
    {
        dialog.getWindow().setLayout(-1, -2);
        dialog.getWindow().getAttributes().windowAnimations = R.style.DialogAnimation;
        Window window = getDialog().getWindow();
        WindowManager.LayoutParams params = window.getAttributes();
        params.dimAmount = 1.0f;
        window.setAttributes(params);
        window.setBackgroundDrawableResource(android.R.color.transparent);
    }
}

0

यह सबसे सरल उपाय है

सबसे अच्छा समाधान जो मैंने पाया है उसके onCreateDialog()बजाय ओवरराइड करना है onCreateView()। setContentView () फुलाए जाने से पहले सही विंडो आयाम सेट करेगा। यह संसाधन फ़ाइलों में एक आयाम, पृष्ठभूमि का रंग, शैली, आदि को संग्रहीत / सेट करने और उन्हें मैन्युअल रूप से सेट करने की आवश्यकता को हटाता है।

@Override
public Dialog onCreateDialog(Bundle savedInstanceState) {
    Dialog dialog = new Dialog(getActivity());
    dialog.setContentView(R.layout.fragment_dialog);

    Button button = (Button) dialog.findViewById(R.id.dialog_button);
    // ...
    return dialog;
}

0

अपने में जोड़ें FragmentDialog:

public void onResume() {
    Window window = getDialog().getWindow();
    Point size = new Point();
    Display display = window.getWindowManager().getDefaultDisplay();
    display.getSize(size);
    window.setLayout( (int)(size.x * 0.9), WindowManager.LayoutParams.WRAP_CONTENT );
    window.setGravity( Gravity.CENTER );
    super.onResume();
}

0

यह पूरी तरह से काम करेगा।

@Override
public void onResume() {
    super.onResume();
    Window window = getDialog().getWindow();
    if(window == null) return;
    WindowManager.LayoutParams params = window.getAttributes();
    params.width = 400;
    params.height = 400;
    window.setAttributes(params);
}

यह बहुत ज्यादा है जो 3+ साल पहले से स्वीकृत उत्तर कहता है।
आदिल हुसैन

-4

एक डायलॉग प्राप्त करने के लिए जो लगभग पूरी तरह से कवर करता है: पहले एक स्क्रीनपैरमीटर वर्ग को परिभाषित करें

public class ScreenParameters
{
    public static int Width;
    public static  int Height;

    public ScreenParameters()
    {
        LayoutParams l = new LayoutParams(LayoutParams.MATCH_PARENT,LayoutParams.MATCH_PARENT);
        Width= l.width;
        Height = l.height;
    }
}

फिर आपको अपने getDialog.getWindow ()। SetLayout () विधि से पहले ScreenParamater को कॉल करना होगा।

@Override
public void onResume()
{
    super.onResume();
    ScreenParameters s = new ScreenParameters();
    getDialog().getWindow().setLayout(s.Width , s.Height);
}
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.