लेआउटइनफ्लेटर अटैचमेंट्स रूट पैरामीटर का क्या अर्थ है?

Question

LayoutInflater.inflate दस्तावेज attachToRoot पैरामीटर के प्रयोजन के बारे में बिल्कुल स्पष्ट नहीं है।

attachToRoot: फुलाया पदानुक्रम रूट पैरामीटर के साथ संलग्न किया जाना चाहिए कि क्या? यदि गलत है, तो रूट का उपयोग केवल XML में रूट व्यू के लिए लेआउट पैराम्स के सही उप-वर्ग बनाने के लिए किया जाता है।

किसी को, और अधिक विस्तार से समझा सकते हैं कृपया विशेष रूप से क्या जड़ दृश्य है, और हो सकता है true और false मूल्यों के बीच व्यवहार में बदलाव का का एक उदाहरण दिखाते हैं?

Answer 1

जब आप माता-पिता को परिभाषित करते हैं तो attachToRoot निर्धारित करता है कि क्या आप चाहते हैं कि inflater वास्तव में माता-पिता को संलग्न करे या नहीं। कुछ मामलों में यह समस्याएं उत्पन्न करता है, जैसे ListAdapter में यह अपवाद का कारण बनता है क्योंकि सूची सूची में दृश्य जोड़ने की कोशिश करती है लेकिन यह कहती है कि यह पहले ही संलग्न है। अन्य पक्षपात में जहां आप एक गतिविधि में जोड़ने के लिए स्वयं को दृश्य को बढ़ा रहे हैं, यह आसान हो सकता है और आपको कोड की एक पंक्ति बचा सकता है।

Answer 2

यदि सत्य पर सेट किया गया है तो आपका लेआउट फुलाए जाने पर इसे स्वचालित रूप से बच्चे के रूप में दूसरे पैरामीटर में निर्दिष्ट व्यूग्रुप के दृश्य पदानुक्रम में जोड़ा जाएगा। उदाहरण के लिए यदि रूट पैरामीटर LinearLayout था तो आपका फुलाया दृश्य स्वचालित रूप से उस दृश्य के बच्चे के रूप में जोड़ा जाएगा।

यदि यह गलत पर सेट किया गया है तो आपका लेआउट फुलाया जाएगा लेकिन किसी भी अन्य लेआउट से जुड़ा नहीं जाएगा (इसलिए इसे खींचा नहीं जाएगा, टच इवेंट आदि प्राप्त नहीं होगा)।

Answer 3

प्रलेखन और दो पिछले उत्तर पर्याप्त होना चाहिए, बस मेरे कुछ विचार।

inflate विधि लेआउट फ़ाइलों को बढ़ाने के लिए उपयोग की जाती है। उन फुलाए गए लेआउट के साथ आपको सीधे माता-पिता ViewGroup पर संलग्न करने की संभावना है या बस उस लेआउट फ़ाइल से दृश्य पदानुक्रम को बढ़ाएं और सामान्य दृश्य पदानुक्रम के बाहर इसके साथ काम करें।

पहले मामले में attachToRoot पैरामीटर true (या बहुत सरल उपयोग inflate विधि है कि एक लेआउट फ़ाइल और एक माता पिता जड़ ViewGroup (गैर null) लेता है) करने के लिए सेट करना होगा। इस मामले में View लौटाया गया है ViewGroup जो विधि में पारित किया गया था, ViewGroup जिसमें फुलाया गया दृश्य पदानुक्रम जोड़ा जाएगा।

दूसरे विकल्प के लिए लौटा फ़ाइल View लेआउट फ़ाइल से रूट ViewGroup है। यदि आपको include-merge pair question से हमारी अंतिम चर्चा याद है, तो यह merge की सीमा के कारणों में से एक है (जब merge के साथ एक लेआउट फ़ाइल रूट हो जाती है, तो आपको एक माता-पिता और attachedToRoot को true पर सेट करना होगा)। यदि आपके पास रूट के साथ एक लेआउट फ़ाइल है merge टैग और attachedToRootfalse पर सेट किया गया था तो inflate विधि के पास merge के बराबर नहीं होने के बराबर कुछ भी नहीं होगा। साथ ही, जैसा कि प्रलेखन कहता है, inflate संस्करण attachToRootfalse पर सेट करना महत्वपूर्ण है क्योंकि आप माता-पिता से सही LayoutParams के साथ दृश्य पदानुक्रम बना सकते हैं।कुछ मामलों में यह महत्वपूर्ण है, AdapterView के बच्चों के साथ सबसे उल्लेखनीय, ViewGroup का उप-वर्ग, जिसके लिए addView() विधियां सेट समर्थित नहीं है। मुझे यकीन है कि आप getView() विधि में इस लाइन का उपयोग कर याद कर रहा हूँ:

convertView = inflater.inflate(R.layout.row_layout, parent, false); 

इस लाइन सुनिश्चित करता है कि फुलाया R.layout.row_layout फ़ाइल सही LayoutParamsAdapterView उपवर्ग उसकी जड़ ViewGroup पर सेट से है। यदि आप ऐसा नहीं करेंगे तो रूट लेआउट फ़ाइल के साथ कुछ समस्याएं हो सकती हैं यदि रूट RelativeLayout था। TableLayout/TableRow में कुछ विशेष और महत्वपूर्ण LayoutParams भी हैं और आपको यह सुनिश्चित करना चाहिए कि उनमें के विचार सही LayoutParams हैं।

Answer 4

, यही कारण है कि मैं एक कोड उदाहरण के साथ इस वर्ष प्रश्न को पुनर्जीवित करने का फैसला किया है, प्रतिक्रियाओं, लेकिन कोई कोड में पाठ का एक बहुत की तरह लगता है कई प्रतिक्रियाओं में उल्लेखित व्यक्ति:

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

क्या है कि वास्तव में कोड (सबसे प्रोग्रामर क्या समझ) में इसका मतलब है:

public class MyCustomLayout extends LinearLayout { 
    public MyCustomLayout(Context context) { 
     super(context); 
     // Inflate the view from the layout resource and pass it as child of mine (Notice I'm a LinearLayout class). 

     LayoutInflater.from(context).inflate(R.layout.child_view, this, true); 
    } 
} 

सूचना है कि पिछले कोड की MyCustomLayout की वजह से attachToRoot परम true है बच्चे के रूप में लेआउट R.layout.child_view जोड़ रहा है और लेआउट प्रदान करती है माता-पिता के पैरा उसी तरह से जैसे कि मैं addView प्रोग्रामेटिक रूप से उपयोग कर रहा हूं, या जैसा कि मैंने इसे XML में किया था:

आपको यह निर्दिष्ट है कि आप अपने आप जड़ वस्तु होने की myView चाहता था और किसी भी माता-पिता के लिए देते नहीं है

LinearLayout linearLayout = new LinearLayout(context); 
linearLayout.setLayoutParams(new LayoutParams(
    LayoutParams.MATCH_PARENT, LayoutParams.WRAP_CONTENT)); 
linearLayout.setOrientation(LinearLayout.VERTICAL); 
    // Create a stand-alone view 
View myView = LayoutInflater.from(context) 
    .inflate(R.layout.ownRootView, null, false); 
linearLayout.addView(myView); 

पिछले कोड में:

निम्नलिखित कोड परिदृश्य जब attachRootfalse के रूप में गुजर बताते हैं बाद में हमने इसे LinearLayout के हिस्से के रूप में जोड़ा लेकिन एक पल के लिए यह एक अकेला (कोई अभिभावक) दृश्य नहीं था।

यही बात टुकड़े के साथ होता है, तो आप उन्हें पहले से मौजूद किसी समूह में जोड़ने के लिए और इसे का हिस्सा हो सकता है, या बस पैरामीटर भेजने:

inflater.inflate (R.layout.fragment, अशक्त, झूठी);

यह निर्दिष्ट करने के लिए कि यह स्वयं की जड़ होगी।

Answer 5

मैं inflate विधि में attachToRoot का असली उद्देश्य क्या था, इस बारे में भी उलझन में था। यूआई अध्ययन का एक सा के बाद, मैं अंत में इस सवाल का जवाब मिल गया:

माता-पिता:

इस मामले में विजेट/लेआउट उस दृश्य वस्तुओं है कि आप findViewById का उपयोग कर को बढ़ाने के लिए() चाहते आसपास रहा है।

attachToRoot:

देता उनके माता पिता को देखा गया तो किसी भी स्पर्श घटना है कि विचारों प्राप्त भी जनक दृश्य में स्थानांतरित हो जाएगा (उन्हें माता-पिता पदानुक्रम में भी शामिल है),। अब यह माता-पिता तक है कि क्या वह उन घटनाओं का मनोरंजन करना चाहता है या उन्हें अनदेखा करना चाहता है। यदि गलत पर सेट किया गया है, तो वे माता-पिता के प्रत्यक्ष बच्चों के रूप में नहीं जोड़े जाते हैं और माता-पिता दृश्यों से किसी भी स्पर्श ईवेंट प्राप्त नहीं करते हैं।

आशा इस भ्रम को सही पर

Answer 6

attachToRoot सेट को साफ करता है इसका मतलब है inflatedView जनक दृश्य के पदानुक्रम में जोड़ दिया जाएगा। इस प्रकार उपयोगकर्ताओं द्वारा संभवतः "देखा" और भावना स्पर्श घटनाओं (या किसी भी अन्य यूआई संचालन) हो सकता है। अन्यथा, यह अभी बनाया गया है, किसी भी दृश्य पदानुक्रम में जोड़ा नहीं गया है और इस प्रकार स्पर्श घटनाओं को देखा या संभाल नहीं किया जा सकता है।

आईओएस एंड्रॉयड के लिए नए डेवलपर के लिए, attachToRoot सही पर सेट किया मतलब है कि आप इस विधि कॉल:

[parent addSubview:inflatedView]; 

तो आगे आप पूछ सकते हैं के लिए जा रहा: क्यों मैं जनक दृश्य अगर मैं false को attachToRoot सेट पारित करना चाहिए? ऐसा इसलिए है क्योंकि आपके एक्सएमएल पेड़ में मूल तत्व को कुछ लेआउटपैम (जैसे मिलान अभिभावक) की गणना करने के लिए मूल दृश्य की आवश्यकता होती है।

Answer 7

inflate() विधि के लिए प्रलेखन के कारण इस विषय पर बहुत भ्रम है।

सामान्य रूप से, अगर अटैच टोट रूट सही पर सेट किया गया है, तो पहले पैरामीटर में निर्दिष्ट लेआउट फ़ाइल को उस समय दूसरे पैरामीटर में निर्दिष्ट व्यू ग्रुप को फुलाया और संलग्न किया गया है। जब attachToRoot गलत होता है, तो पहले पैरामीटर से लेआउट फ़ाइल फुलाया जाता है और दृश्य के रूप में लौटाया जाता है और किसी अन्य समय पर कोई भी दृश्य संलग्नक होता है।

यह संभवतः तब तक बहुत अधिक मतलब नहीं है जब तक आप बहुत सारे उदाहरण नहीं देखते। Fragment के onCreateView विधि के अंदर LayoutInflater.inflate() को कॉल करते समय, आप attachToRoot के लिए गलत में गुजरना चाहते हैं क्योंकि उस टुकड़े से जुड़ी गतिविधि वास्तव में उस टुकड़े के दृश्य को जोड़ने के लिए ज़िम्मेदार है। यदि आप मैन्युअल रूप से कुछ दृश्य बिंदु पर किसी अन्य दृश्य में दृश्य को जोड़ रहे हैं और जोड़ रहे हैं, जैसे कि addView() विधि के साथ, आप attachToRoot के लिए गलत में गुजरना चाहते हैं क्योंकि अटैचमेंट समय के बाद में आता है।

आप इस विषय के बारे में लिखने वाले ब्लॉग पोस्ट पर संवाद और कस्टम दृश्य से संबंधित कई अन्य अनूठे उदाहरणों के बारे में पढ़ सकते हैं।

https://www.bignerdranch.com/blog/understanding-androids-layoutinflater-inflate/

Answer 8

उदाहरण के लिए हम एक ImageView, एक LinearLayout और एक RelativeLayout है। LinearLayout RelativeLayout का बच्चा है। दृश्य पदानुक्रम होगा।

RelativeLayout 
      ------->LinearLayout 

और हम imageView

image_view_layout के लिए एक अलग लेआउट फ़ाइल है।एक्सएमएल

जड़ को संलग्न करें:

//here container is the LinearLayout 

    View v = Inflater.Inflate(R.layout.image_view_layout,container,true); 

1. यहाँ वी यानी कंटेनर लेआउट के संदर्भ है LinearLayout.and आप imageView की setImageResource(R.drawable.np); आप करेंगे जैसे पैरामीटर सेट करना चाहते हैं इसे माता-पिता के संदर्भ में ढूंढना है यानी view.findById()
2. वी का अभिभावक फ्रेमलेआउट होगा।
3. लेआउटपैम फ्रेमलेआउट का होगा।

जड़ से संलग्न नहीं:

//here container is the LinearLayout 
    View v = Inflater.Inflate(R.layout.image_view_layout,container,false); 

1. यहाँ v imageView है कि आप बिना view.setImageResource(R.drawable.np); की तरह अपने पैरामीटर सेट कर सकते हैं ताकि हवा भरी जाती है के लिए कोई संदर्भ कंटेनर लेआउट लेकिन प्रत्यक्ष संदर्भ है findViewById की तरह रेफरिंग। लेकिन कंटेनर निर्दिष्ट किया गया है ताकि ImageView को कंटेनर का लेआउट पैराम प्राप्त हो ताकि आप कह सकें कि कंटेनर का संदर्भ केवल लेआउट पैराम्स के लिए कुछ भी नहीं है।
2. इसलिए विशेष रूप से माता-पिता शून्य हो जाएंगे।
3. लेआउटपैरम लीनियरआउट के होंगे।

Answer 9

attachToRoot को सही पर सेट करें:

attachToRoot सही पर सेट किया जाता है, तो लेआउट पहले पैरामीटर में निर्दिष्ट फ़ाइल फुलाया और ViewGroup दूसरा पैरामीटर में निर्दिष्ट से जुड़ा हुआ है।

कल्पना कीजिए कि हमने एक एक्सएमएल लेआउट फ़ाइल में एक बटन निर्दिष्ट किया है जिसमें इसकी लेआउट चौड़ाई और लेआउट ऊंचाई match_parent पर सेट है।

<Button xmlns:android="http://schemas.android.com/apk/res/android" 
      android:layout_width="match_parent" 
      android:layout_height="match_parent" 
      android:id="@+id/custom_button"> 
</Button> 

अब हम प्रोग्राम के रूप में एक टुकड़ा या गतिविधि के अंदर एक LinearLayout को यह बटन जोड़ना चाहते हैं। यदि हमारे LinearLayout पहले से ही एक सदस्य चर रहा है, mLinearLayout, हम बस बटन निम्नलिखित के साथ जोड़ सकते हैं:

inflater.inflate(R.layout.custom_button, mLinearLayout, true); 

हम निर्दिष्ट है कि हम अपने लेआउट संसाधन फ़ाइल से बटन को बढ़ाने के लिए चाहते हैं; फिर हम लेआउट इन्फ्लेटर को बताते हैं कि हम इसे mLinearLayout से जोड़ना चाहते हैं। हमारे लेआउट पैरामीटर सम्मानित हैं क्योंकि हम जानते हैं कि बटन एक लीनियरलाउट में जोड़ा जाता है। बटन का लेआउट पैराम्स प्रकार LinearLayout होना चाहिए। LayoutParams।

attachToRoot झूठी (गलत उपयोग की आवश्यकता नहीं)

attachToRoot गलत पर सेट है, तो लेआउट पहले पैरामीटर में निर्दिष्ट फ़ाइल फुलाया जाता है और नहीं से जुड़ी इस पर सेट करें ViewProup दूसरे पैरामीटर में निर्दिष्ट है, लेकिन फुलाए गए माता-पिता के लेआउट पैराम प्राप्त करते हैं जो उस दृश्य को माता-पिता में सही ढंग से फिट करने में सक्षम बनाता है।

की है जब आप गलत पर attachToRoot सेट करना चाहते हैं पर एक नज़र डालते हैं। इस परिदृश्य में, inflate() के पहले पैरामीटर में निर्दिष्ट दृश्य समय बिंदु पर दूसरे पैरामीटर में ViewGroup से जुड़ा हुआ नहीं है।

पहले से हमारे बटन उदाहरण को याद करें, जहां हम लेआउट फ़ाइल से mLinearLayout पर एक कस्टम बटन संलग्न करना चाहते हैं। हम अभी भी अटूट टॉर रूट के लिए झूठ में गुजरकर हमारे बटन को mLinearLayout से जोड़ सकते हैं- हम इसे मैन्युअल रूप से बाद में जोड़ते हैं। कोड की

Button button = (Button) inflater.inflate(R.layout.custom_button, mLinearLayout, false); 
mLinearLayout.addView(button); 

इन दो पंक्तियों को हम क्या कोड की एक पंक्ति में पहले लिखा था जब हम attachToRoot के लिए सच में पारित करने के लिए बराबर हैं। झूठ बोलकर, हम कहते हैं कि हम अभी तक रूट व्यू ग्रुप पर अपना व्यू संलग्न नहीं करना चाहते हैं। हम कह रहे हैं कि यह समय पर किसी अन्य बिंदु पर होगा। इस उदाहरण में, समय में दूसरा बिंदु बस मुद्रास्फीति के नीचे उपयोग की गई addView() विधि है।

झूठी अटैचमेंट टोर रूट उदाहरण को थोड़ा और काम करने की आवश्यकता होती है जब हम मैन्युअल रूप से व्यू ग्रुप में व्यू जोड़ते हैं।

attachToRoot गलत पर सेट (गलत आवश्यकता होती है)

जब बढ़ा-चढ़ाकर और onCreateView (में एक टुकड़ा के दृश्य लौटने), attachToRoot के लिए झूठी में पारित करने के लिए सुनिश्चित करें। यदि आप सच में गुजरते हैं, तो आपको एक IllegalStateException मिलेगा क्योंकि निर्दिष्ट बच्चे के पास पहले से ही एक अभिभावक है। आपको यह निर्दिष्ट करना चाहिए था कि आपकी फ्रैगमेंट का दृश्य आपकी गतिविधि में वापस रखा जाएगा। FragmentManager का काम Fragments जोड़ने, हटाने और बदलने के लिए है।

FragmentManager fragmentManager = getSupportFragmentManager(); 
Fragment fragment = fragmentManager.findFragmentById(R.id.root_viewGroup); 

if (fragment == null) { 
fragment = new MainFragment(); 
fragmentManager.beginTransaction() 
    .add(R.id.root_viewGroup, fragment) 
    .commit(); 
} 

root_viewGroup कंटेनर है कि आपके गतिविधि में अपने टुकड़ा का आयोजन करेगा() ViewGroup पैरामीटर अपने टुकड़ा में onCreateView में आप के लिए दिया जाता है। यह ViewGroup भी है जिसे आप लेआउटइनफ्लर.inflate() में पास करते हैं। FragmentManager इस दृश्य समूह को आपके Fragment के दृश्य को संलग्न करने में संभाल करेगा, हालांकि। आप इसे दो बार संलग्न नहीं करना चाहते हैं। संलग्न करने के लिए संलग्न करें।

public View onCreateView(LayoutInflater inflater, ViewGroup parentViewGroup, Bundle savedInstanceState) { 
View view = inflater.inflate(R.layout.fragment_layout,  parentViewGroup, false); 
… 
return view; 
} 

क्यों हम अपने टुकड़ा की मूल ViewGroup दिया जाता है पहली जगह में अगर हम onCreateView में संलग्न कर दें नहीं करना चाहते()? Inflate() विधि रूट व्यू समूह का अनुरोध क्यों करती है?

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

लिंक: https://youtu.be/1Y0LlmTCOkM?t=409

Answer 10

अब या नहीं अब

"तीसरा" पैरामीटर attachToRoot सही या गलत होने के बीच मुख्य अंतर यह है।

जब आप attachToRoot डाल

सच: माता पिता अधिकार अब
गलत पर बच्चे दृश्य जोड़ने: माता पिता नहीं अब के लिए बच्चे दृश्य जोड़ने।
इसे बाद में जोड़ें। `

बाद में कब है?

बाद में है कि जब आप जैसे parent.addView(childView)

एक आम धारणा है, है अगर attachToRoot पैरामीटर गलत है तो बच्चे को देखने के लिए माता-पिता को नहीं जोड़ा जाएगा के लिए इस्तेमाल करते हैं। WRONG
दोनों मामलों में बाल दृश्य को parentView में जोड़ा जाएगा। यह सिर्फ समय का मामला है।

inflater.inflate(child,parent,false); 
parent.addView(child); 

आप attachToRoot पारित नहीं किया जाना चाहिए के रूप में सच है जब आप माता-पिता के लिए बच्चे दृश्य जोड़ने के लिए जिम्मेदार नहीं हैं

inflater.inflate(child,parent,true); 

एक बड़ी नहीं-नहीं
के बराबर है।
जैसे जोड़ने टुकड़ा

public View onCreateView(LayoutInflater inflater,ViewGroup parent,Bundle bundle) 
    { 
     super.onCreateView(inflater,parent,bundle); 
     View v = inflater.inflate(R.layout.image_fragment,parent,false); 
     ..... 
     return true 
    } 

जब अगर आप तीसरे पैरामीटर के रूप में सच्चा आप इस आदमी की वजह से IllegalStateException मिल जाएगा गुजरती हैं।

getSupportFragmentManager() 
     .beginTransaction() 
     .add(parent, childFragment) 
     .commit(); 

जब से तुम गलती से पहले ही onCreateView() में बाल टुकड़ा जोड़ लिया है। कॉलिंग ऐड आपको बताएगा कि बाल दृश्य पहले से ही माता-पिता में जोड़ा गया है इसलिए IllegalStateException।
यहां आप बाल दृश्य जोड़ने के लिए ज़िम्मेदार नहीं हैं, FragmentManager ज़िम्मेदार है। तो हमेशा इस मामले में झूठी गुजरती है।

नोट: मैंने यह भी पढ़ा है कि parentView बच्चे नहीं मिलेगा स्पर्श स्पर्श अगर संलग्न है तो रूट गलत है। लेकिन मैंने इसका परीक्षण नहीं किया है।

Answer 11

मैंने यह जवाब लिखा क्योंकि कई स्टैक ओवरफ्लो पृष्ठों के माध्यम से जाने के बाद भी मैं स्पष्ट रूप से समझ नहीं पाया कि अटूट टोट्रूट का क्या अर्थ है। लेआउट इन्फ्लूटर क्लास में नीचे inflate() विधि है।

View inflate (int resource, ViewGroup root, boolean attachToRoot) 

activity_main.xml फ़ाइल, button.xml लेआउट और मैं बनाया MainActivity.java फ़ाइल पर एक नजर डालें।

activity_main.xml

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" 
    android:id="@+id/root" 
    android:layout_width="match_parent" 
    android:layout_height="match_parent" 
    android:orientation="vertical"> 

</LinearLayout> 

button.xml

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

MainActivity.java

@Override 
protected void onCreate(Bundle savedInstanceState) { 
    super.onCreate(savedInstanceState); 
    setContentView(R.layout.activity_main); 

    LayoutInflater inflater = getLayoutInflater(); 
    LinearLayout root = (LinearLayout) findViewById(R.id.root); 
    View view = inflater.inflate(R.layout.button, root, false); 
} 

जब हम कोड चलाते हैं, हम नहीं बटन लेआउट में देखेंगे । ऐसा इसलिए है क्योंकि हमारा बटन लेआउट मुख्य गतिविधि लेआउट में नहीं जोड़ा गया है क्योंकि attachToRoot को गलत पर सेट किया गया है।

रैखिकलायआउट में ऐड व्यू (देखें व्यू) विधि जिसका उपयोग लाइनरलाउट पर दृश्य जोड़ने के लिए किया जा सकता है। यह मुख्य लेआउट लेआउट में बटन लेआउट जोड़ देगा, और जब आप कोड चलाते हैं तो बटन को दृश्यमान बना देगा।

root.addView(view); 

की पिछली पंक्ति को दूर करते हैं, और देखो क्या होता है जब हम के रूप में सच attachToRoot निर्धारित किया है।

View view = inflater.inflate(R.layout.button, root, true); 

फिर हम देखते हैं कि बटन लेआउट दृश्यमान है। ऐसा इसलिए है क्योंकि attachToRoot सीधे निर्दिष्ट माता-पिता को फुलाए गए लेआउट को जोड़ता है। जो इस मामले में रूट LinearLayout है। यहां हमें मैन्युअल रूप से दृश्यों को जोड़ने की ज़रूरत नहीं है जैसे हमने पिछले मामले में addView (व्यू व्यू) विधि के साथ किया था।

फ्रैगमेंट के लिए अटैच टॉट रूट को सेट करते समय लोगों को अवैध स्तर अपवाद क्यों मिल रहा है।

ऐसा इसलिए है क्योंकि एक टुकड़े के लिए आपने पहले से ही निर्दिष्ट किया है कि अपनी गतिविधि फ़ाइल में अपना टुकड़ा लेआउट कहां रखा जाए।

FragmentManager fragmentManager = getSupportFragmentManager(); 
fragmentManager.beginTransaction() 
    .add(R.id.root, fragment) 
    .commit(); 

ऐड (पूर्णांक माता पिता, टुकड़ा टुकड़ा) टुकड़ा जो उसे अपने जनक लेआउट के लिए लेआउट है है कहते हैं। अगर हम attachToRoot को सत्य के रूप में सेट करते हैं, तो आपको IllegalStateException मिलेगा: निर्दिष्ट बच्चे के पास पहले से ही एक अभिभावक है। चूंकि खंड लेआउट पहले से ही() विधि में पैरेंट लेआउट में जोड़ा गया है।

जब आप फ्रैगमेंट्स को बढ़ा रहे हों तो आपको हमेशा अटैच करने के लिए झूठ बोलना चाहिए। FragmentManager का काम Fragments जोड़ने, हटाने और बदलने के लिए है।

मेरे उदाहरण पर वापस जाएं। अगर हम दोनों करते हैं तो क्या होगा।

View view = inflater.inflate(R.layout.button, root, true); 
root.addView(view); 

पहली पंक्ति में, LayoutInflater जड़ लेआउट के लिए बटन लेआउट लगा देते हैं और एक दृश्य वस्तु है जो एक ही बटन लेआउट रखती देता है। दूसरी पंक्ति में, हम वही व्यू ऑब्जेक्ट मूल रूट लेआउट में जोड़ते हैं। इसका परिणाम उसी IllegalStateException में होता है जिसे हमने Fragments के साथ देखा (निर्दिष्ट बच्चे के पास पहले से ही एक अभिभावक है)।

ध्यान रखें कि एक और अधिभारित inflate() विधि है, जो डिफ़ॉल्ट रूप से संलग्न करने के लिए संलग्न करता है।

View inflate (int resource, ViewGroup root)