Android क्या है: android में weightSum, और यह कैसे काम करता है?

Question

मैं जानना चाहता हूं: एंड्रॉइड क्या है: वेटसम और लेआउट वजन, और वे कैसे काम करते हैं?

Answer 1

प्रति प्रलेखन, android:weightSumअधिकतम वजन राशि को परिभाषित करता है, और layout_weightयदि स्पष्ट रूप से निर्दिष्ट नहीं किया गया है तो सभी बच्चों के योग के रूप में गणना की जाती है ।

आइए LinearLayoutक्षैतिज अभिविन्यास के साथ एक उदाहरण पर विचार करें और ImageViewsइसके अंदर 3 । अब हम चाहते हैं कि ये ImageViewsहमेशा बराबर जगह लें। इसे स्वीकार करने के लिए, आप layout_weightप्रत्येक ImageViewको 1 में सेट कर सकते हैं और weightSumटिप्पणी में दिखाए गए अनुसार 3 के बराबर होने की गणना की जाएगी।

<LinearLayout
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    <!-- android:weightSum="3" -->
    android:orientation="horizontal"
    android:layout_gravity="center">

   <ImageView
       android:layout_height="wrap_content"       
       android:layout_weight="1"
       android:layout_width="0dp"/>
  .....

weightSum किसी भी उपकरण के लिए सही तरीके से प्रस्तुत किए गए लेआउट के लिए उपयोगी है, जो कि सीधे चौड़ाई और ऊंचाई निर्धारित करने पर नहीं होगा।

Comments

यह उद्देश्य के बारे में स्पष्टीकरण नहीं है weightSum। आपके उदाहरण में व्यवहार weightSumलोप के समान होगा , और वास्तव में उस परिदृश्य में वेटसम को निर्दिष्ट नहीं किया जाना चाहिए। प्रलेखन कहते हैं,weightSum Defines the maximum weight sum. If unspecified, the sum is computed by adding the layout_weight of all of the children.

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

@ जेफे एक्सग्रॉड: यह "निर्दिष्ट नहीं किया जाना चाहिए"? क्यों? मुझे उसका कोई कारण नजर नहीं आता। इसलिए मैं सिर्फ यह कहूंगा कि इसे निर्दिष्ट करने की आवश्यकता नहीं है।

— दोपहर

@ मर्कोव .: इसका रखरखाव की वजह से निर्दिष्ट नहीं किया जाना चाहिए। जैसा कि जेफ ने कहा, वेटसम को लेआउट के अंदर वजन के बराबर होने के लिए सेट करना कुछ भी नहीं पूरा करता है, लेकिन अगर कोई इसे भविष्य में बदलता है तो यह सिरदर्द का कारण बन सकता है क्योंकि अब लेआउट के लिए एक अनावश्यक संशोधक है जिसे ढूंढना होगा और बदल गया। यह उत्तर गलत है और स्वीकृत उत्तर नहीं होना चाहिए।

— d370urn3ur

वेटसुम पैरामीटर की अच्छी व्याख्या न देखें, इसलिए डॉक्स से: "इसका उपयोग उदाहरण के लिए कुल उपलब्ध स्थान के 50% बच्चे को 0.5 का लेआउट_वेट देकर और वेटसम को 1.0 पर सेट करने के लिए किया जा सकता है।" डेवलपर

— .android.com

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

— एडवर्ड फॉक

Answer 2

सुपरएम और जेफ के जवाब को जोड़ते हुए,

यदि रैखिक व्यूआउट में 2 दृश्य हैं, पहला लेआउट_वेट 1 के साथ, दूसरा लेआउट_वेट 2 के साथ और कोई वेटसम नहीं है, डिफ़ॉल्ट रूप से, वेटसम की गणना 3 (बच्चों के वजन की राशि) और पहला दृश्य 1/3 स्थान लेता है जबकि दूसरा 2/3 लेता है।

हालाँकि, अगर हम वेटसुम को 5 के रूप में निर्दिष्ट करते हैं, तो पहला स्थान 1/5 वें स्थान पर ले जाएगा जबकि दूसरा 2/5 वां स्थान लेगा। इसलिए कुल 3/5 वें स्थान को बाकी खाली रखने के लिए लेआउट द्वारा कब्जा कर लिया जाएगा।

Comments

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

— DeltaCap019

क्या यह सच है कि भारोत्तोलन के साथ लेआउट की तुलना में RelativeLayout का उपयोग करने की सिफारिश की गई है?

— रॉबर्ट

Answer 3

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

android:layout_width="0dp" 

निम्नलिखित एक उदाहरण है

    <LinearLayout
                android:layout_width="500dp"
                android:layout_height="20dp" >

                <TextView
                    android:layout_width="0dp"
                    android:layout_height="match_parent"
                    android:layout_weight="3"
                    android:background="@android:color/holo_green_light"
                    android:gravity="center"
                    android:text="30%"
                    android:textColor="@android:color/white" >
                </TextView>

                <TextView
                    android:layout_width="0dp"
                    android:layout_height="match_parent"
                    android:layout_weight="2"
                    android:background="@android:color/holo_blue_bright"
                    android:gravity="center"
                    android:text="20%"
                    android:textColor="@android:color/white" >
                </TextView>

                <TextView
                    android:layout_width="0dp"
                    android:layout_height="match_parent"
                    android:layout_weight="5"
                    android:background="@android:color/holo_orange_dark"
                    android:gravity="center"
                    android:text="50%"
                    android:textColor="@android:color/white" >
                </TextView>
 </LinearLayout>

ऐसा लगेगा

Answer 4

प्रलेखन यह सबसे अच्छा कहते हैं और एक उदाहरण है, (मेरा प्रकाश डाला) भी शामिल है।

एंड्रॉयड: weightSum

अधिकतम वजन योग को परिभाषित करता है। यदि अनिर्दिष्ट है, तो सभी बच्चों के लेआउट_वेट को जोड़कर योग की गणना की जाती है। उदाहरण के लिए इसका उपयोग एकल बच्चे को कुल उपलब्ध स्थान का 50% देने के लिए किया जा सकता है, इसे 0.5 का लेआउट_वेट और 1.0 के लिए वेटसम सेट करके।

तो सुपरम के उदाहरण को सही करने के लिए, मान लीजिए कि आपके पास LinearLayoutक्षैतिज अभिविन्यास है जिसमें दो ImageViewsऔर एक के TextViewसाथ है। आप TextViewएक निश्चित आकार के लिए परिभाषित करते हैं , और आप दोनों ImageViewsको शेष स्थान को समान रूप से लेना चाहते हैं ।

इसे पूरा करने के लिए, आप layout_weightप्रत्येक पर 1 ImageView, किसी पर भी TextViewऔर weightSum2.0 पर लागू करेंगे LinearLayout।

Answer 5

कुछ प्रयोग करने के बाद, मुझे लगता है कि LinearLayout के लिए एल्गोरिथ्म यह है:

मान लें कि मान weightSumपर सेट है। अनुपस्थिति के मामले पर बाद में चर्चा की जाती है।

सबसे पहले, weightSumwhith match_parentया fill_parentLinearLayout (उदाहरण के layout_widthलिए orientation="horizontal") के आयाम में तत्वों की संख्या से विभाजित करें । हम इस मूल्य को प्रत्येक तत्व के लिए वजन गुणक कहेंगे । के लिए डिफ़ॉल्ट मान weightSum1.0 है, इसलिए डिफ़ॉल्ट वजन गुणक है 1/n, जहां तत्वों nकी संख्या है fill_parent; wrap_contentतत्वों में योगदान नहीं है n।

जैसे जब weightSum६० है, और ३ fill_parentतत्व हैं, वजन गुणक २० है। वजन गुणक उदाहरण के लिए डिफ़ॉल्ट मान है layout_widthयदि विशेषता अनुपस्थित है।

दूसरा, हर तत्व का अधिकतम संभव विस्तार गणना है। सबसे पहले, wrap_contentतत्वों को उनकी सामग्री के अनुसार गणना की जाती है। उनका विस्तार मूल कंटेनर के विस्तार से काटा जाता है। हम बचे को बुलाएंगे expansion_remainer। यह शेष fill_parentतत्वों के अनुसार उनके बीच वितरित किया जाता है layout_weight।

तीसरा, हर fill_parentतत्व का विस्तार निम्नानुसार है:

उदाहरण:

यदि weightSum60 है, और 3 fill_parentतत्वों के साथ 10, 20 और 30 हैं, तो स्क्रीन पर उनका विस्तार मूल कंटेनर का 2/3, 1/3 और 0/3 है।

weight | expansion
     0 | 3/3
    10 | 2/3
    20 | 1/3
    30 | 0/3
    40 | 0/3

न्यूनतम विस्तार 0 पर छाया हुआ है। अधिकतम विस्तार को मूल आकार में कैप किया गया है, अर्थात 0 पर टेप किया गया है।

यदि कोई तत्व सेट किया गया है wrap_content, तो इसके विस्तार की गणना पहले की जाती है, और शेष विस्तार fill_parentतत्वों के बीच वितरण के अधीन है । यदि weightSumसेट किया जाता है, तो इससे तत्वों layout_weightपर कोई प्रभाव नहीं पड़ता wrap_contentहै। हालांकि, wrap_contentतत्वों को अभी भी दृश्य क्षेत्र से बाहर धकेल दिया जा सकता है ऐसे तत्व जिनका वजन कम है (उदाहरण के लिए 0-1 से weightSum= 1 के बीच या उपरोक्त उदाहरण के लिए 0-20 के बीच)।

यदि कोई weightSumनिर्दिष्ट नहीं है, तो इसे सभी layout_weightमानों के योग के रूप में गणना की जाती है , जिसमेंwrap_content सेट के साथ तत्व भी शामिल हैं ! इसलिए तत्वों layout_weightपर सेट होने से wrap_content, उनके विस्तार को प्रभावित किया जा सकता है । उदा। एक नकारात्मक भार अन्य fill_parentतत्वों को सिकोड़ देगा । fill_parentतत्वों के बिछाए जाने से पहले , उपरोक्त सूत्र को wrap_contentतत्वों पर लागू किया जाएगा , अधिकतम संभव विस्तार के साथ लिपटे सामग्री के अनुसार उनका विस्तार। wrap_contentतत्वों सिकुड़ जाएगी, और बाद में शेष के लिए अधिकतम संभव विस्तार fill_parentतत्वों की गणना की और वितरित किया जाता है।

इससे अनपेक्षित परिणाम हो सकते हैं।

Answer 6

यदि अनिर्दिष्ट है, तो सभी बच्चों के लेआउट_वेट को जोड़कर योग की गणना की जाती है। उदाहरण के लिए इसका उपयोग एकल बच्चे को कुल उपलब्ध स्थान का 50% हिस्सा देने के लिए किया जा सकता है, इसे 0.5 का लेआउट_वेट और 1.0 के लिए वेटसम सेट करके। एक अस्थायी बिंदु मान होना चाहिए, जैसे "1.2"

    <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
        android:id="@+id/main_rel"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:orientation="horizontal"
        android:weightSum="2.0" >

        <RelativeLayout
            android:id="@+id/child_one"
            android:layout_width="match_parent"
            android:layout_height="match_parent"
            android:layout_weight="1.0"
            android:background="#0000FF" >
        </RelativeLayout>

        <RelativeLayout
            android:id="@+id/child_two"
            android:layout_width="match_parent"
            android:layout_height="match_parent"
            android:layout_weight="1.0"
            android:background="#00FF00" >
        </RelativeLayout>

    </LinearLayout>

Comments

'फ्लोटिंग पॉइंट वैल्यू हो सकती है, जैसे "1.2"। ( developer.android.com/reference/android/widget/… )

— अविश्वसनीय

Answer 7

एक चीज़ जो किसी और के समान नहीं लगती है: मान लीजिए कि आपके पास एक लंबवत है LinearLayout , इसलिए लेआउट में तत्व / तत्व / इसके अंदर देखने के लिए 100% ठीक से काम करने के लिए - इन सभी के पास layout_heightसंपत्ति होनी चाहिए (जो आपके xml में मौजूद होनी चाहिए) फ़ाइल) पर सेट है 0dp। किसी भी अन्य मूल्य की तरह लगता है कुछ मामलों में चीजों को गड़बड़ाना होगा।

Comments

एंड्रॉइड: लेआउट_ एक्सपोज़र = "माचिस_परेंट" आमतौर पर 0dp के बजाय उपयोग किया जाता है

— kc ochibili

ऐसा क्यों हैं? मेरा मतलब है कि आप सही कह रहे हैं कि यह गड़बड़ है, लेकिन 0 dp की ऊंचाई तय करने से मेरी समस्या हल हो गई। मुझे इसका कारण जानना होगा।

— अब्दुल वहीद

Answer 8

लेआउट भार एक अनुपात की तरह काम करता है। उदाहरण के लिए, यदि एक लंबवत लेआउट है और दो आइटम हैं (जैसे बटन या टेक्स्ट साक्षात्कार), एक लेआउट वेट 2 और दूसरा लेआउट वेट 3 क्रमशः। फिर 1 आइटम स्क्रीन / लेआउट के 5 भाग में से 2 पर कब्जा कर लेगा और अन्य 5 में से 3 भाग। यहां 5 का वजन है। अर्थात भार योग पूरे लेआउट को परिभाषित भागों में विभाजित करता है। और लेआउट वेट यह परिभाषित करता है कि कुल वेट सम से परिभाषित पूर्व में विशेष मद में कितना हिस्सा है। वजन राशि को मैन्युअल रूप से भी घोषित किया जा सकता है। यूआई डिजाइन के लिए रैखिक लेआउट का उपयोग करते समय बटन, टेक्स्टव्यू, एडिटेक्स आदि सभी को वेटसम और लेआउट वजन का उपयोग करके आयोजित किया जाता है।

Answer 9

डेवलपर प्रलेखन से

उदाहरण के लिए इसका उपयोग 50%कुल उपलब्ध स्थान के एक बच्चे को एक 0.5लेआउट देने के लिए किया जा सकता है 1.0।

@ शुभीय उत्तर को जोड़

बाकी 3/5का उपयोग अन्य बच्चे के लेआउट के लिए किया जा सकता है जो वास्तव में लेआउट वाले किसी विशिष्ट भाग की आवश्यकता नहीं है।

यह android:weightSumसंपत्ति का संभावित उपयोग है ।