क्या लेआउटइंटरफ़्लैटर संलग्नकूट पैरामीटर का मतलब है?

Question

LayoutInflater.inflateप्रलेखन बिल्कुल के उद्देश्य के बारे में मेरे लिए स्पष्ट नहीं है attachToRootपैरामीटर।

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

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

Comments

संबंधित: LayoutInflater की समझ बनाना

— blahdiblah

डुप्लिकेट: stackoverflow.com/questions/22326314/…

— mikebabcock

Answer 1

अभी या अभी नहीं

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

जब आप देते हैं संलग्नकूट

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

वह बाद में कब है ?

बाद में जब आप उदाहरण के लिए उपयोग करते हैं parent.addView(childView)

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

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

के बराबर है

inflater.inflate(child,parent,true);

जब आप माता-पिता के लिए बच्चे के दृष्टिकोण को जोड़ने के लिए ज़िम्मेदार नहीं होते हैं, तो आपको कोई नहीं नहीं-नहीं संलग्न करना चाहिए।
जैसे जब खुशबू जोड़ते हैं

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

यदि आप तीसरे पैरामीटर को सही मानते हैं तो आपको इस आदमी की वजह से IllegalStateException मिल जाएगी।

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

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

ध्यान दें: मैंने यह भी पढ़ा है कि अगर संलग्नक झूठा है, तो parentView को चाइल्ड व्यू टचविंट्स नहीं मिलेंगे। लेकिन मैंने हालांकि इसका परीक्षण नहीं किया है।

Comments

बहुत उपयोगी, विशेष रूप से के बारे में हिस्सा FragmentManager, धन्यवाद!

— साइबेक्स

Answer 2

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

यदि यह गलत पर सेट है, तो आपका लेआउट फुलाया जाएगा, लेकिन किसी अन्य लेआउट से संलग्न नहीं किया जाएगा (इसलिए इसे तैयार नहीं किया जाएगा, स्पर्श घटनाओं को प्राप्त करें)।

Comments

मैं उलझन में हूं। मैं एक जब तक मैंने पढ़ा "विनिर्दिष्ट बच्चे पहले से ही एक माता पिता त्रुटि है" हो रही थी इस जवाब है, जो निर्देशित मेरी उपयोग करने के लिए falseके लिए attachToRootमेरे टुकड़ा के दौरान onCreateView। यह समस्या और अभी तक टुकड़ा के लेआउट, दृश्य और सक्रिय है आपका जवाब के बावजूद हल किया। पर क्या हो रहा है यहाँ?

— जेफ एक्सल्रॉड

क्योंकि एक टुकड़ा स्वचालित रूप से onCreateView से लौटे लेआउट को संलग्न करता है। इसलिए यदि आप इसे onCreateView में मैन्युअल रूप से संलग्न करते हैं तो आपका दृष्टिकोण 2 माता-पिता से जुड़ जाता है (जो आपके द्वारा उल्लिखित त्रुटि पैदा करता है)।

— जोसेफ अर्ल

मैं यहाँ थोड़ा उलझन में हूँ, @JosephEarl आपने कहा कि यदि सेट किया जाता है true, तो दृश्य 2 पैरामीटर से जुड़ा होता है container, जो है , लेकिन फिर आप कहते हैं कि टुकड़ा स्वचालित रूप से जुड़ा हुआ है onCreateView(), इसलिए मेरी समझ में, तीसरा पैरामीटर बेकार है और इसे सेट किया जाना चाहिए falseहमेशा?

— अनम्यूटेमेडियो

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

— ठंढाईदार

@unmultimedio द्वारा लौटाए गए मूल दृश्य के लिए यह केवल बेकार है onCreateView। यदि आप आगे के लेआउट को उस मूल दृश्य में शामिल करते हैं, या आप किसी भिन्न संदर्भ (जैसे किसी गतिविधि में) को फुला रहे हैं तो यह उपयोगी है।

— जोसेफ अर्ल

Answer 3

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

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

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

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);
    }
}

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

<LinearLayout>
   <View.../>
   ...
</LinearLayout>

जब गुजर निम्नलिखित कोड परिदृश्य बताते हैं attachRootके रूप में false:

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);

पिछले कोड में आप निर्दिष्ट करते हैं कि आप myViewस्वयं इसकी मूल वस्तु बनना चाहते थे और इसे किसी भी माता-पिता के साथ संलग्न न करें, बाद में हमने इसे LinearLayoutएक हिस्से के रूप में जोड़ा, लेकिन एक पल के लिए यह एक स्टैंड-अलोन (कोई अभिभावक) नहीं था।

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

inflater.inflate (R.layout.fragment, null, false);

यह निर्दिष्ट करने के लिए कि यह स्वयं का मूल होगा।

Comments

सभी में से, यह सबसे उपयोगी था।

— वाहिब उल हक

Answer 4

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

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

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

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

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

यह रेखा सुनिश्चित करती है कि फुलाया गया R.layout.row_layoutफ़ाइल उसके रूट पर सेट उपवर्ग LayoutParamsसे सही है । यदि आप ऐसा नहीं कर रहे हैं तो आपको रूट फ़ाइल के साथ कुछ समस्याएँ हो सकती हैं यदि रूट a । यह भी कुछ विशेष और महत्वपूर्ण है और क्या आप वाकई उन में देखा गया सही है बनाना चाहिए ।AdapterViewViewGroupRelativeLayoutTableLayout/TableRowLayoutParamsLayoutParams

Answer 5

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

माता-पिता:

इस मामले में विजेट / लेआउट है जो उन व्यू ऑब्जेक्ट्स के आसपास है, जिन्हें आप findViewById () का उपयोग करके फुलाते हैं।

attachToRoot:

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

आशा है कि यह भ्रम को साफ करता है

Comments

आप जवाब दे रहे हैं पहले से ही यहाँ प्रदान किया गया है: stackoverflow.com/questions/22326314/…

— नियॉन वारगे

Answer 6

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

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);
}

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

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

root.addView(view);

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

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

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

जब लोग Fragment के लिए trueToRoot को सेट करते समय IllegalStateException प्राप्त कर रहे हैं।

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

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

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

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

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

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

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

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

View inflate (int resource, ViewGroup root)

Comments

सरल और स्पष्ट स्पष्टीकरण, बस मैं क्या देख रहा था!

— फ्लाइंगआसिस्टेंट

Answer 7

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

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

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

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

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

Answer 8

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

Android के लिए iOS डेवलपर्स नए के लिए, attachToRootसही मायने में सेट करने के लिए आप इस विधि को कहते हैं:

[parent addSubview:inflatedView];

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

Answer 9

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

Comments

एक स्पष्ट तस्वीर नहीं देता है जो एक अच्छा जवाब प्रदान करना चाहिए।

— प्रखर १००१ १३'१1 को १२:३1

Answer 10

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

RelativeLayout
           ------->LinearLayout

और हमारे पास ImageView के लिए एक अलग लेआउट फ़ाइल है

image_view_layout.xml

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

//here container is the LinearLayout

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

1. यहाँ v में कंटेनर लेआउट का संदर्भ होता है अर्थात LinearLayout.and और यदि आप setImageResource(R.drawable.np);ImageView जैसे पैरामीटर सेट करना चाहते हैं, तो आपको इसे माता-पिता के संदर्भ में ढूंढना होगा अर्थातview.findById()
2. V का जनक फ्रेमलेयआउट होगा।
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 11

AttToRoot सही पर सेट करें:

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

कल्पना करें कि हमने XML लेआउट फ़ाइल में एक बटन निर्दिष्ट किया है जिसकी लेआउट चौड़ाई और लेआउट की ऊंचाई 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>

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

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

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

अनुलग्नक को सेट करें गलत पर सेट करें (गलत का उपयोग करने के लिए आवश्यक नहीं)

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

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

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

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

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

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

संलग्न करें झूठी पर सेट करें (झूठी आवश्यक है)

जब OnCreateView () में एक फ़्रैगमेंट के दृश्य को फुलाया और वापस किया जा रहा है, तो संलग्नक के लिए झूठे में पास होना सुनिश्चित करें। यदि आप सच में गुजरते हैं, तो आपको एक अवैध संबंध मिल जाएगा क्योंकि निर्दिष्ट बच्चे के पास पहले से ही एक माता-पिता हैं। आपको निर्दिष्ट करना चाहिए कि आपके फ्रैगमेंट का दृश्य आपकी गतिविधि में वापस कहाँ रखा जाएगा। यह 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();
}

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

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

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

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

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

Answer 12

इस विषय पर काम करते समय मैंने जो कुछ बिंदुओं का सामना किया है, उन्हें साझा करना।

स्वीकृत उत्तर के अलावा मैं कुछ बिंदुओं पर जाना चाहता हूं जो कुछ मदद के हो सकते हैं।

इसलिए, जब मैंने अट्रैक्शन को सही के रूप में उपयोग किया था, तो जो दृश्य लौटाया गया था, वह प्रकार था ViewGroup अर्थात माता-पिता की मूल ViewGroup, जो फ़्लोरेट के लिए पैरामीटर के रूप में पारित किया गया था (LayoutResource, ViewGroup, AttToRoot) विधि, उस लेआउट के प्रकार की नहीं, जो पारित किया गया था, लेकिन संलग्नक पर झूठे के रूप में हम चाहते हैं कि layoutResource के रूट के समारोह वापसी प्रकार प्राप्त ViewGroup ।

मुझे एक उदाहरण के साथ समझाएं:

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

तब के प्रयोग पर attachToRoot के रूप में सच्चा बढ़ समारोह एक रिटर्न देखें प्रकार के LinearLayout

जबकि प्रयोग पर attachToRoot के रूप में झूठी बढ़ समारोह एक रिटर्न देखें प्रकार के TextView

आशा है कि इस खोज से कुछ मदद मिलेगी ...