कैसे मैं इसे टूटने के बिना एक स्क्रॉल में एक सूची दृश्य डाल सकते हैं?

351

मैंने इस समस्या के समाधान के लिए चारों ओर खोज की है, और एकमात्र उत्तर जो मुझे मिल सकता है, वह है " एक स्क्रॉल दृश्य में एक सूची दृश्य न डालें " "। मुझे अभी तक किसी भी वास्तविक स्पष्टीकरण को देखना है कि हालांकि क्यों । एकमात्र कारण जो मुझे लग सकता है, वह यह है कि Google को नहीं लगता कि आपको ऐसा करना चाहिए। वैसे मैं करता हूं, इसलिए मैंने किया।

तो सवाल यह है कि, बिना अपनी न्यूनतम ऊँचाई तक पहुँचने के बिना आप एक स्क्रॉल दृश्य में एक सूची दृश्य कैसे रख सकते हैं?

android  android-listview  android-scrollview 
— DougW
स्रोत
11
क्योंकि जब कोई डिवाइस टच स्क्रीन का उपयोग करता है तो दो नेस्टेड स्क्रॉल करने योग्य कंटेनरों के बीच अंतर करने का कोई अच्छा तरीका नहीं है। यह पारंपरिक डेस्कटॉप पर काम करता है जहां आप कंटेनर स्क्रॉल करने के लिए स्क्रॉलबार का उपयोग करते हैं।
— रोमेन गाइ
57
ज़रूर है। यदि वे भीतर एक को छूते हैं, तो उसे स्क्रॉल करें। यदि आंतरिक एक बहुत बड़ा है, तो यह बुरा यूआई डिज़ाइन है। इसका मतलब यह नहीं है कि यह सामान्य रूप से एक बुरा विचार है।
— डौग
5
बस मेरे टेबलेट ऐप के लिए इस पर ठोकर खाई। हालांकि यह स्मार्टफ़ोन पर बहुत बुरा नहीं लगता है, यह एक टैबलेट पर भयानक है जहां आप आसानी से तय कर सकते हैं कि उपयोगकर्ता बाहरी या आंतरिक स्क्रॉल दृश्य को स्क्रॉल करना चाहता है या नहीं। @ डौग: भयानक डिजाइन, मैं सहमत हूं।
— जेलिफ़िश
4
@ रोमेन - यह एक काफी पुरानी पोस्ट है, इसलिए मुझे आश्चर्य हो रहा है कि क्या यहाँ की चिंताओं को पहले ही संबोधित कर दिया गया है, या अभी भी स्क्रॉलव्यू के अंदर एक सूची दृश्य का उपयोग करने का कोई अच्छा तरीका नहीं है (या एक विकल्प जो मैन्युअल कोडिंग शामिल नहीं है। एक LinearLayout में एक ListView के सभी स्थानों)?
— जिम
3
@Jim: "या एक विकल्प जिसमें लिस्ट व्यू के सभी निशानों को मैन्युअल रूप से कोड करना शामिल नहीं होता है" - एक सब कुछ अंदर डालें ListView। ListViewकई पंक्ति शैलियों, गैर-चयन योग्य पंक्तियाँ हो सकती हैं।
— कॉमन्सवेअर

जवाबों:

196

ListViewस्क्रॉल नहीं करने के लिए इसका उपयोग करना बहुत महंगा है और इसके पूरे उद्देश्य के विरुद्ध जाता है ListView। आपको ऐसा नहीं करना चाहिए । LinearLayoutइसके बजाय बस का उपयोग करें ।

— रोमेन गाइ
स्रोत
69
जब से मैं पिछले 2 या 3 वर्षों से ListView का प्रभारी हूं, स्रोत मेरे पास होगा :) ListView एडेप्टर के उपयोग को अनुकूलित करने के लिए बहुत सारे अतिरिक्त काम करता है। इसके चारों ओर काम करने की कोशिश करने से लिस्ट व्यू को बहुत सारे काम करने पड़ेंगे। मैं विवरणों में नहीं जाऊँगा क्योंकि सूची दृश्य के कार्यान्वयन की व्याख्या करने के लिए यहाँ पर्याप्त जगह नहीं है। यह भी दृश्य को स्पर्श करने के संबंध में ListView के व्यवहार के तरीके को हल नहीं करेगा। इस बात की भी कोई गारंटी नहीं है कि अगर आपका हैक आज काम करता है तो यह भविष्य के रिलीज में भी काम करेगा। LinearLayout का उपयोग करना वास्तव में बहुत काम नहीं होगा।
— रोमेन गाइ
7
खैर यह एक उचित प्रतिक्रिया है। यदि मैं कुछ प्रतिक्रिया साझा कर सकता हूं, तो मेरे पास बहुत अधिक महत्वपूर्ण iPhone अनुभव है, और मैं आपको बता सकता हूं कि Apple की प्रलेखन प्रदर्शन विशेषताओं और इस तरह के मामलों (या विरोधी पैटर्न) का उपयोग करने के संबंध में बेहतर लिखा गया है। कुल मिलाकर, Android प्रलेखन अधिक वितरित और कम केंद्रित है। मैं समझता हूं कि इसके पीछे कुछ कारण हैं, लेकिन यह एक लंबी चर्चा है, इसलिए यदि आप इसके बारे में चैट करने के लिए मजबूर महसूस करते हैं तो मुझे बताएं।
— डग डब्लू
6
आप आसानी से एक स्थैतिक विधि लिख सकते हैं जो एक अडैप्टर से लिनियर लयआउट बनाता है।
— रोमेन गाइ
125
यह एक उत्तर नहीं है How can I put a ListView into a ScrollView without it collapsing?... आप बता सकते हैं कि आपको ऐसा नहीं करना चाहिए, लेकिन यह भी करना चाहिए कि यह कैसे करें, यह एक अच्छा जवाब है। आपको पता है कि एक सूची दृश्य में स्क्रॉलिंग के अलावा कुछ अन्य शांत विशेषताएं हैं, ऐसी विशेषताएं जो रैखिकअरआउट के पास नहीं हैं।
— जॉर्ज फ्यूएंटेस गोंजालेज़
44
क्या होगा यदि आपके पास एक ऐसा क्षेत्र है जिसमें लिस्ट व्यू + अन्य दृश्य हैं, और आप चाहते हैं कि सब कुछ एक के रूप में स्क्रॉल करें? ऐसा लगता है कि स्क्रॉल दृश्य के भीतर एक सूची दृश्य रखने के लिए एक उचित उपयोग-मामला है। LinearLayout के साथ ListView को बदलना एक समाधान नहीं है क्योंकि तब आप एडेप्टर का उपयोग नहीं कर सकते हैं।
— बैरी फ्रूटमैन
262

यहाँ मेरा समाधान है। मैं एंड्रॉइड प्लेटफॉर्म के लिए काफी नया हूं, और मुझे यकीन है कि यह थोड़ा हैकिश है, विशेष रूप से कॉलिंग के बारे में।LayoutParams.height सीधे संपत्ति , लेकिन यह काम करता है।

आपको बस कॉल करना है Utility.setListViewHeightBasedOnChildren(yourListView)और इसकी वस्तुओं की ऊंचाई को ठीक करने के लिए इसका आकार बदलना होगा।

public class Utility {
    public static void setListViewHeightBasedOnChildren(ListView listView) {
        ListAdapter listAdapter = listView.getAdapter();
        if (listAdapter == null) {
            // pre-condition
            return;
        }

        int totalHeight = listView.getPaddingTop() + listView.getPaddingBottom();

        for (int i = 0; i < listAdapter.getCount(); i++) {
            View listItem = listAdapter.getView(i, null, listView);
            if (listItem instanceof ViewGroup) {
                listItem.setLayoutParams(new LayoutParams(LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT));
             }

             listItem.measure(0, 0);
             totalHeight += listItem.getMeasuredHeight();
        }

        ViewGroup.LayoutParams params = listView.getLayoutParams();
        params.height = totalHeight + (listView.getDividerHeight() * (listAdapter.getCount() - 1));
        listView.setLayoutParams(params);
    }
}
— DougW
स्रोत
66
आपने अभी-अभी एक बहुत ही महंगा लिनलेयआउट बनाया है
— रोमेन गाइ
82
सिवाय इसके LinearLayoutसभी के पास अंतर्निहित निचे ListViewनहीं है - इसमें डिवाइडर, हेडर / पाद दृश्य, एक सूची चयनकर्ता नहीं है जो फोन के यूआई थीम रंगों आदि से मेल खाता है, ईमानदारी से, कोई कारण नहीं है कि आप स्क्रॉल नहीं कर सकते। आंतरिक कंटेनर जब तक यह अंत तक नहीं पहुंच जाता है और तब तक यह स्पर्श घटनाओं को रोकना बंद कर देता है ताकि बाहरी कंटेनर स्क्रॉल हो जाए। प्रत्येक डेस्कटॉप ब्राउज़र ऐसा तब करता है जब आप अपने स्क्रॉल व्हील का उपयोग कर रहे होते हैं। यदि आप ट्रैकबॉल के माध्यम से नेविगेट कर रहे हैं, तो एंड्रॉइड स्वयं नेस्टेड स्क्रॉलिंग को संभाल सकता है, तो स्पर्श के माध्यम से क्यों नहीं?
— नील ट्रैफ़्ट
29
listItem.measure(0,0)यदि N इसे तब फेंकेगा जब listItem एक ViewGroup उदाहरण है। मैंने पहले निम्नलिखित को जोड़ा listItem.measure:if (listItem instanceof ViewGroup) listItem.setLayoutParams(new LayoutParams(LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT));
— Siklab.ph
4
0 के अलावा अन्य पैडिंग के साथ सूची दृश्य के लिए फिक्स:int totalHeight = listView.getPaddingTop() + listView.getPaddingBottom();
— पॉल
8
दुर्भाग्य से यह विधि थोड़ी त्रुटिपूर्ण है जब ListViewइसमें परिवर्तनशील ऊँचाई की वस्तुएँ हो सकती हैं। getMeasuredHeight()वास्तविक ऊंचाई के विपरीत कॉल केवल लक्षित न्यूनतम ऊंचाई लौटाती है। मैंने getHeight()इसके बजाय का उपयोग करने की कोशिश की , लेकिन यह रिटर्न 0. क्या किसी को इस बारे में कोई अंतर्दृष्टि है कि इसे कैसे प्राप्त किया जाए?
— मैट हगिंस
89

यह निश्चित रूप से काम करेगा ............
आपको <ScrollView ></ScrollView>इस Custom ScrollViewतरह से अपने लेआउट को XML फ़ाइल में बदलना होगा<com.tmd.utils.VerticalScrollview > </com.tmd.utils.VerticalScrollview > 

package com.tmd.utils;

import android.content.Context;
import android.util.AttributeSet;
import android.util.Log;
import android.view.MotionEvent;
import android.widget.ScrollView;

public class VerticalScrollview extends ScrollView{

    public VerticalScrollview(Context context) {
        super(context);
    }

     public VerticalScrollview(Context context, AttributeSet attrs) {
            super(context, attrs);
        }

        public VerticalScrollview(Context context, AttributeSet attrs, int defStyle) {
            super(context, attrs, defStyle);
        }

    @Override
    public boolean onInterceptTouchEvent(MotionEvent ev) {
        final int action = ev.getAction();
        switch (action)
        {
            case MotionEvent.ACTION_DOWN:
                    Log.i("VerticalScrollview", "onInterceptTouchEvent: DOWN super false" );
                    super.onTouchEvent(ev);
                    break;

            case MotionEvent.ACTION_MOVE:
                    return false; // redirect MotionEvents to ourself

            case MotionEvent.ACTION_CANCEL:
                    Log.i("VerticalScrollview", "onInterceptTouchEvent: CANCEL super false" );
                    super.onTouchEvent(ev);
                    break;

            case MotionEvent.ACTION_UP:
                    Log.i("VerticalScrollview", "onInterceptTouchEvent: UP super false" );
                    return false;

            default: Log.i("VerticalScrollview", "onInterceptTouchEvent: " + action ); break;
        }

        return false;
    }

    @Override
    public boolean onTouchEvent(MotionEvent ev) {
        super.onTouchEvent(ev);
        Log.i("VerticalScrollview", "onTouchEvent. action: " + ev.getAction() );
         return true;
    }
}
— अतुल भारद्वाज
स्रोत
4
यह बहुत अच्छा है। यह स्क्रॉलव्यू के अंदर Google मैप्स फ्रैगमेंट रखना भी संभव बनाता है, और यह अभी भी ज़ूम इन / आउट काम करता है। धन्यवाद।
— मैग्नस जोहानसन
क्या किसी ने इस दृष्टिकोण के साथ किसी भी विपक्ष को देखा है? इसका इतना आसान मुझे डर है: o
— Marija Milosevic
1
अच्छा समाधान, स्वीकृत उत्तर +1 होना चाहिए! मैंने इसे नीचे (djunod से) उत्तर के साथ मिलाया है, और यह बहुत अच्छा है!
— tanou
1
यह एकमात्र फिक्स है जो मेरे लिए एक ही समय में काम करने वाले बच्चों पर स्क्रॉलिंग और क्लिक करता है। बड़ा धन्यवाद
— पेलेडॉल्फो
25

ListViewएक के अंदर डालने के लिए ScrollView, हम ListViewएक के रूप में उपयोग कर सकते हैं ScrollView। जिन चीजों में ListViewहोना है, उन्हें अंदर रखा जा सकता है ListView। शीर्ष और नीचे के अन्य लेआउट ListViewको हेडर और के पाद में लेआउट जोड़कर रखा जा सकता है ListView। तो पूरा ListViewआपको स्क्रॉल करने का अनुभव देगा।

— अरुण
स्रोत
3
यह सबसे सुरुचिपूर्ण और उपयुक्त उत्तर इम्हो है। इस दृष्टिकोण पर अधिक जानकारी के लिए, इस उत्तर को देखें: stackoverflow.com/a/20475821/1221537
— adamdport
21

वहाँ बहुत सारी स्थितियाँ हैं जहाँ यह एक बहुत कुछ समझ में आता है एक स्क्रॉल दृश्य में है।

यहाँ कोड डग के सुझाव पर आधारित है ... एक टुकड़े में काम करता है, कम स्मृति लेता है।

public static void setListViewHeightBasedOnChildren(ListView listView) {
    ListAdapter listAdapter = listView.getAdapter();
    if (listAdapter == null) {
        return;
    }
    int desiredWidth = MeasureSpec.makeMeasureSpec(listView.getWidth(), MeasureSpec.AT_MOST);
    int totalHeight = 0;
    View view = null;
    for (int i = 0; i < listAdapter.getCount(); i++) {
        view = listAdapter.getView(i, view, listView);
        if (i == 0) {
            view.setLayoutParams(new ViewGroup.LayoutParams(desiredWidth, LayoutParams.WRAP_CONTENT));
        }
        view.measure(desiredWidth, MeasureSpec.UNSPECIFIED);
        totalHeight += view.getMeasuredHeight();
    }
    ViewGroup.LayoutParams params = listView.getLayoutParams();
    params.height = totalHeight + (listView.getDividerHeight() * (listAdapter.getCount() - 1));
    listView.setLayoutParams(params);
    listView.requestLayout();
}

प्रत्येक एम्बेडेड सूची पर callListViewHeightBasedOnChildren (listview) कॉल करें।

— djunod
स्रोत
यह तब काम नहीं करेगा जब सूची-वस्तुएं चर आकार की हों, यानी कुछ टेक्स्टव्यू जो कई लाइनों में विस्तारित हों। कोई भी समाधान?
— खोबिब
यहाँ मेरी टिप्पणी की जाँच करें - यह सही समाधान देता है - stackoverflow.com/a/23315696/1433187
— खोबिब
मेरे लिए एपीआई 19 के साथ काम किया, लेकिन एपीआई 23 के साथ नहीं: यहां यह सूची दृश्य के नीचे बहुत अधिक सफेद स्थान जोड़ता है।
— लक्जर 10
17

लिस्ट व्यू वास्तव में पहले से ही सभी वस्तुओं को प्रदर्शित करने के लिए खुद को लंबा करने के लिए मापने में सक्षम है, लेकिन यह तब नहीं होता है जब आप केवल रैप_ कॉन्टेंट (मेज़स्पेक्ट.यूएनएसईसीईसीआईईडी) निर्दिष्ट करते हैं। यह तब करेगा जब यह मापने के लिए दिया जाएगा। इस ज्ञान के साथ, आप इस समस्या को हल करने के लिए एक बहुत ही सरल उपवर्ग बना सकते हैं जो ऊपर दिए गए किसी भी समाधान की तुलना में कहीं बेहतर काम करता है। आपको अभी भी इस उपवर्ग के साथ wra_content का उपयोग करना चाहिए।

public class ListViewForEmbeddingInScrollView extends ListView {
    public ListViewForEmbeddingInScrollView(Context context) {
        super(context);
    }

    public ListViewForEmbeddingInScrollView(Context context, AttributeSet attrs) {
        super(context, attrs);
    }

    public ListViewForEmbeddingInScrollView(Context context, AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
    }

    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        super.onMeasure(widthMeasureSpec, MeasureSpec.makeMeasureSpec(Integer.MAX_VALUE >> 4, MeasureSpec.AT_MOST));
    }
}

एक बहुत बड़े आकार (Integer.MAX_VALUE >> 4) के साथ AT_MOST होने के लिए heightMeasureSpec का हेरफेर लिस्ट व्यू को उसके सभी बच्चों को दी गई (बहुत बड़ी) ऊंचाई तक मापने और तदनुसार उसकी ऊंचाई निर्धारित करने का कारण बनता है।

यह कुछ कारणों से अन्य समाधानों की तुलना में बेहतर काम करता है:

  1. यह सब कुछ सही ढंग से मापता है (पैडिंग, डिवाइडर)
  2. यह माप पास के दौरान ListView को मापता है
  3. # 2 के कारण, यह किसी भी अतिरिक्त कोड के बिना सही ढंग से चौड़ाई या आइटम की संख्या में परिवर्तन को संभालता है

नकारात्मक पक्ष पर, आप तर्क दे सकते हैं कि ऐसा करने से एसडीके में अनैच्छिक व्यवहार पर भरोसा किया जा सकता है जो बदल सकता है। दूसरी ओर, आप यह तर्क दे सकते हैं कि इस तरह से wra_content को वास्तव में ListView के साथ काम करना चाहिए और वर्तमान wra_content व्यवहार बस टूट गया है।

यदि आप चिंतित हैं कि व्यवहार भविष्य में बदल सकता है, तो आपको बस सूची फ़ंक्शन और संबंधित कार्यों को ListView.java से बाहर और अपने स्वयं के उपवर्ग में कॉपी करना चाहिए, फिर UNSPIFIFIED के लिए ऑनमॉर रन के माध्यम से AT_MOST पथ बनाएं।

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

— जेसन वाई
स्रोत
भी सूची में चर ऊंचाई आइटम के साथ काम करता है!
— डेनी
@ जेसन वाई इसका क्या करता है, Integer.MAX_VALUE >> 4 का मतलब ?? 4 क्या है ??
— KJEjava48
मेरे लिए @Jason Y ने केवल तभी काम किया जब मैंने Integer.MAX_VALUE >> 2 को Integer.MAX_VALUE >> 21 में बदल दिया। ऐसा क्यों? इसके अलावा यह स्क्रॉल के साथ काम करता है। नेस्टेडक्रोल व्यू के साथ नहीं।
— KJEjava48
13

इसके लिए एक अंतर्निहित सेटिंग है। स्क्रॉल दृश्य पर:

android:fillViewport="true"

जावा में,

mScrollView.setFillViewport(true);

रोमैन गाइ ने इसे यहां गहराई से समझाया: http://www.curious-creature.org/2010/08/15/scrollviews-handy-tac/

— TalkLittle
स्रोत
2
वह एक रेखीयआउट के लिए काम करता है क्योंकि वह प्रदर्शित करता है। यह एक ListView के लिए काम नहीं करता है। उस पोस्ट की तारीख के आधार पर, मुझे लगता है कि उन्होंने इसे अपने विकल्प का उदाहरण देने के लिए लिखा था, लेकिन यह इस सवाल का जवाब नहीं देता है।
— डगडब्लू
यह तेज़ समाधान है
10

आप कस्टम लिस्ट बनाएं जो कि स्क्रॉल करने योग्य न हो

public class NonScrollListView extends ListView {

    public NonScrollListView(Context context) {
        super(context);
    }
    public NonScrollListView(Context context, AttributeSet attrs) {
        super(context, attrs);
    }
    public NonScrollListView(Context context, AttributeSet attrs, int defStyle) {
        super(context, attrs, defStyle);
    }
    @Override
    public void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
            int heightMeasureSpec_custom = MeasureSpec.makeMeasureSpec(
                    Integer.MAX_VALUE >> 2, MeasureSpec.AT_MOST);
            super.onMeasure(widthMeasureSpec, heightMeasureSpec_custom);
            ViewGroup.LayoutParams params = getLayoutParams();
            params.height = getMeasuredHeight();    
    }
}

आपकी लेआउट संसाधन फ़ाइल में

<RelativeLayout
    android:layout_width="match_parent"
    android:layout_height="wrap_content" >

    <!-- com.Example Changed with your Package name -->

    <com.Example.NonScrollListView
        android:id="@+id/lv_nonscroll_list"
        android:layout_width="match_parent"
        android:layout_height="wrap_content" >
    </com.Example.NonScrollListView>

    <RelativeLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_below="@+id/lv_nonscroll_list" >

        <!-- Your another layout in scroll view -->

    </RelativeLayout>
</RelativeLayout>

जावा फ़ाइल में

ListView के बजाय अपने customListview का एक ऑब्जेक्ट बनाएं जैसे: NonScrollListView non_scroll_list = (NonScrollListView) findViewById (R.id.lv_nonscroll_list);

— डेडान्या हिरेनकुमार
स्रोत
8

हम एक साथ दो स्क्रॉलिंग का उपयोग नहीं कर सके। Weeniu की कुल लंबाई मिलेगी। हमारे पास सूची की कुल लंबाई होगी और कुल ऊंचाई के साथ सूची का विस्तार होगा। तब हम स्क्रॉल में सीधे सूची दृश्य को जोड़ सकते हैं या रैखिक का उपयोग कर सकते हैं क्योंकि स्क्रॉलव्यू का सीधा एक बच्चा है। अपने कोड में setListViewHeightBasedOnChildren (lv) विधि की प्रतिलिपि बनाएँ और सूची का विस्तार करें फिर आप स्क्रॉलव्यू के अंदर सूची का उपयोग कर सकते हैं। \ लेआउट xml फ़ाइल

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical" >
 <ScrollView

        android:layout_width="fill_parent"
        android:layout_height="fill_parent"
         android:background="#1D1D1D"
        android:orientation="vertical"
        android:scrollbars="none" >

        <LinearLayout
            android:layout_width="fill_parent"
            android:layout_height="fill_parent"
            android:background="#1D1D1D"
            android:orientation="vertical" >

            <TextView
                android:layout_width="fill_parent"
                android:layout_height="40dip"
                android:background="#333"
                android:gravity="center_vertical"
                android:paddingLeft="8dip"
                android:text="First ListView"
                android:textColor="#C7C7C7"
                android:textSize="20sp" />

            <ListView
                android:id="@+id/first_listview"
                android:layout_width="260dp"
                android:layout_height="wrap_content"
                android:divider="#00000000"
               android:listSelector="#ff0000"
                android:scrollbars="none" />

               <TextView
                android:layout_width="fill_parent"
                android:layout_height="40dip"
                android:background="#333"
                android:gravity="center_vertical"
                android:paddingLeft="8dip"
                android:text="Second ListView"
                android:textColor="#C7C7C7"
                android:textSize="20sp" />

            <ListView
                android:id="@+id/secondList"
                android:layout_width="260dp"
                android:layout_height="wrap_content"
                android:divider="#00000000"
                android:listSelector="#ffcc00"
                android:scrollbars="none" />
  </LinearLayout>
  </ScrollView>

   </LinearLayout>

एक्टिविटी क्लास में ऑनक्रिट विधि:

 import java.util.ArrayList;
  import android.app.Activity;
 import android.os.Bundle;
 import android.view.Menu;
 import android.view.View;
 import android.view.ViewGroup;
 import android.widget.ArrayAdapter;
 import android.widget.ListAdapter;
  import android.widget.ListView;

   public class MainActivity extends Activity {

   @Override
   protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.listview_inside_scrollview);
    ListView list_first=(ListView) findViewById(R.id.first_listview);
    ListView list_second=(ListView) findViewById(R.id.secondList);
    ArrayList<String> list=new ArrayList<String>();
    for(int x=0;x<30;x++)
    {
        list.add("Item "+x);
    }

       ArrayAdapter<String> adapter=new ArrayAdapter<String>(getApplicationContext(), 
          android.R.layout.simple_list_item_1,list);               
      list_first.setAdapter(adapter);

     setListViewHeightBasedOnChildren(list_first);

      list_second.setAdapter(adapter);

    setListViewHeightBasedOnChildren(list_second);
   }



   public static void setListViewHeightBasedOnChildren(ListView listView) {
    ListAdapter listAdapter = listView.getAdapter();
    if (listAdapter == null) {
        // pre-condition
        return;
    }

    int totalHeight = 0;
    for (int i = 0; i < listAdapter.getCount(); i++) {
        View listItem = listAdapter.getView(i, null, listView);
        listItem.measure(0, 0);
        totalHeight += listItem.getMeasuredHeight();
    }

    ViewGroup.LayoutParams params = listView.getLayoutParams();
    params.height = totalHeight
            + (listView.getDividerHeight() * (listAdapter.getCount() - 1));
    listView.setLayoutParams(params);
      }
— आशीष सैनी
स्रोत
अच्छा ठीक है! यह आवश्यकतानुसार काम करता है। धन्यवाद। मेरे मामले में मेरे पास सूची से पहले विचारों का एक पूरा गुच्छा है और सही समाधान यह है कि दृश्य पर सिर्फ एक ऊर्ध्वाधर स्क्रॉल हो।
— नीतिवचन
4

यह डौग, गुड गय ग्रेग और पॉल के उत्तरों का संयोजन है। मैंने पाया कि कस्टम लिस्टव्यू एडॉप्टर और गैर-मानक सूची आइटम के साथ इसका उपयोग करने की कोशिश करते समय यह सब आवश्यक था अन्यथा लिस्टव्यू ने एप्लिकेशन को क्रैश कर दिया (साथ ही नेक्स द्वारा जवाब के साथ दुर्घटनाग्रस्त हो गया):

public void setListViewHeightBasedOnChildren(ListView listView) {
        ListAdapter listAdapter = listView.getAdapter();
        if (listAdapter == null) {
            return;
        }

        int totalHeight = listView.getPaddingTop() + listView.getPaddingBottom();
        for (int i = 0; i < listAdapter.getCount(); i++) {
            View listItem = listAdapter.getView(i, null, listView);
            if (listItem instanceof ViewGroup)
                listItem.setLayoutParams(new LayoutParams(LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT));
            listItem.measure(0, 0);
            totalHeight += listItem.getMeasuredHeight();
        }

        ViewGroup.LayoutParams params = listView.getLayoutParams();
        params.height = totalHeight + (listView.getDividerHeight() * (listAdapter.getCount() - 1));
        listView.setLayoutParams(params);
    }
— परित्यक्त गाड़ी
स्रोत
इस विधि को कहां से करें?
— ध्रुपाल
सूची बनाने और एडॉप्टर सेट करने के बाद।
— कार्ट को
यह लंबी सूचियों पर बहुत धीमा हो जाता है।
— केकण
@cakan यह 2 साल पहले भी कुछ यूआई घटकों को एक साथ उपयोग करने की अनुमति देने के लिए लिखा गया था जो वास्तव में संयुक्त होने का मतलब नहीं है। आप आधुनिक एंड्रॉइड में ओवरहेड की अनावश्यक मात्रा जोड़ रहे हैं, इसलिए यह उम्मीद की जानी चाहिए कि बड़ी होने पर सूची धीमी हो जाएगी।
— कार्ट
3

आपको स्क्रॉल दृश्य में एक सूची दृश्य नहीं डालना चाहिए क्योंकि एक सूची दृश्य पहले से ही एक स्क्रॉल दृश्य है । तो यह एक स्क्रॉल दृश्य में एक स्क्रॉल दृश्य डालने जैसा होगा।

आप क्या खत्म करने की कोशिश कर रहे हैं?

— चेरिल साइमन
स्रोत
4
मैं एक स्क्रॉल दृश्य के अंदर एक सूची दृश्य को पूरा करने की कोशिश कर रहा हूं। मैं नहीं चाहता कि मेरा ListView स्क्रॉल योग्य हो, लेकिन myListView.scrollEnabled = false सेट करने के लिए कोई सरल संपत्ति नहीं है;
— डगडब्लू
जैसा कि रोमेन गाइ ने कहा, यह बहुत ज्यादा नहीं है एक ListView का उद्देश्य। एक सूची दृश्य एक ऐसा दृश्य है, जो मदों की एक लंबी सूची को प्रदर्शित करने के लिए अनुकूलित है, विचारों के आलसी लोडिंग, पुन: उपयोग करने के लिए बहुत सारे जटिल तर्क के साथ, आदि इसमें से कोई भी समझ में नहीं आता है यदि आप सूची दृश्य को स्क्रॉल नहीं करने के लिए कह रहे हैं। यदि आप सिर्फ एक लंबवत कॉलम में वस्तुओं का एक गुच्छा चाहते हैं, तो एक LinearLayout का उपयोग करें।
— चेरिल साइमन
9
समस्या यह है कि आपके द्वारा उल्लिखित एक सूची दृश्य सहित कई समाधान उपलब्ध हैं। डेटा प्रबंधन और नियंत्रण के बारे में यद्यपि एडेप्टर सरलता से कार्य करता है, अधिकांश यूआई अनुकूलन नहीं। IMO में एक साधारण सूची दृश्य होना चाहिए था, और एक अधिक जटिल एक जो सभी सूची आइटम का पुन: उपयोग और सामान करता है।
— डौग
2
बिलकुल राजी है। ध्यान दें कि एक मौजूदा अडैप्टर को लिनियरलैट के साथ प्रयोग करना आसान है, लेकिन मैं उन सभी अच्छी चीजों को चाहता हूं जो डिवाइडर की तरह लिस्टव्यू प्रदान करता है, और यह कि मुझे मैन्युअल रूप से लागू करने का मन नहीं है।
— आर्टेम रसाकोवस्की
1
@ArtemRussakovskii क्या आप कृपया मौजूदा एडॉप्टर के साथ लिंटरलेयूट को लिस्ट व्यू को बदलने का अपना आसान तरीका बता सकते हैं?
— हैप्पीहार्डिक
3

मैंने @ डगडब्ल्यू Utilityको C # में परिवर्तित किया (ज़ामरीन में प्रयुक्त)। निम्नलिखित सूची में निश्चित ऊंचाई वाली वस्तुओं के लिए ठीक काम करता है, और ज्यादातर ठीक होने जा रहा है, या कम से कम एक अच्छी शुरुआत है, अगर केवल कुछ सामान मानक आइटम से थोड़ा बड़ा है।

// You will need to put this Utility class into a code file including various
// libraries, I found that I needed at least System, Linq, Android.Views and 
// Android.Widget.
using System;
using System.Linq;
using Android.Views;
using Android.Widget;

namespace UtilityNamespace  // whatever you like, obviously!
{
    public class Utility
    {
        public static void setListViewHeightBasedOnChildren (ListView listView)
        {
            if (listView.Adapter == null) {
                // pre-condition
                return;
            }

            int totalHeight = listView.PaddingTop + listView.PaddingBottom;
            for (int i = 0; i < listView.Count; i++) {
                View listItem = listView.Adapter.GetView (i, null, listView);
                if (listItem.GetType () == typeof(ViewGroup)) {
                    listItem.LayoutParameters = new LinearLayout.LayoutParams (ViewGroup.LayoutParams.MatchParent, ViewGroup.LayoutParams.WrapContent);
                }
                listItem.Measure (0, 0);
                totalHeight += listItem.MeasuredHeight;
            }

            listView.LayoutParameters.Height = totalHeight + (listView.DividerHeight * (listView.Count - 1));
        }
    }
}

धन्यवाद @DougW, यह मुझे एक तंग जगह से बाहर निकल गया जब मुझे अन्य लोगों केकोड के साथ काम करना पड़ा। :-)

— फिल रयान
स्रोत
एक प्रश्न: आपने setListViewHeightBasedOnChildren()विधि को कब बुलाया ? क्योंकि यह मेरे लिए हर समय काम नहीं करता है।
— अलेक्जेंड्रे डी।
@AlexandreD जब आप आइटमों की सूची बना लेते हैं, तो आप यूटिलिटी .setListViewHeightBasedOnChildren (yourListView) को कॉल करते हैं। यानी सुनिश्चित करें कि आपने पहले अपनी सूची बनाई है! मैंने पाया था कि मैं एक सूची बना रहा था, और मैं अपने आइटम्स को Console.WriteLine में प्रदर्शित कर रहा था ... लेकिन किसी तरह आइटम गलत दायरे में थे। एक बार जब मैंने यह पता लगा लिया, और सुनिश्चित किया कि मेरी सूची के लिए सही गुंजाइश है, तो यह एक आकर्षण की तरह काम करता है।
— फिल रेयान
तथ्य यह है कि मेरी सूची मेरे ViewModel में बनाई गई है। मैं यह कैसे प्रतीक्षा कर सकता हूं कि किसी भी कॉल से पहले मेरे दृश्य में मेरी सूचियाँ उपयोगिता के लिए बनाई गई हों। ListViewHeightBasedOnChildren (yourListView)?
— अलेक्जेंड्रे डी।
3

यह केवल एक चीज है जो मेरे लिए काम करती है:

लॉलीपॉप के बाद आप उपयोग कर सकते हैं

yourtListView.setNestedScrollingEnabled(true);

इस दृश्य के लिए नेस्टेड स्क्रॉलिंग को सक्षम या अक्षम करें यदि आपको ओएस के पुराने संस्करण के साथ पीछे की संगतता की आवश्यकता है, तो आपको रिसाइक्लर व्यू का उपयोग करना होगा।

— Jacka
स्रोत
AppCompat गतिविधि में DialogFragment में API 22 पर मेरी सूची के विचारों पर इसका कोई प्रभाव नहीं पड़ा। वे अभी भी ढहते हैं। @Phil रयान जवाब थोड़ा संशोधन के साथ काम किया।
— हकन Hakलिक एमके १
3

इससे पहले यह संभव नहीं था। लेकिन नए Appcompat पुस्तकालयों और डिजाइन पुस्तकालयों की रिहाई के साथ, यह हासिल किया जा सकता है।

आपको बस NestedScrollView https://developer.android.com/reference/android/support/v4/widget/NestedScrollView.html का उपयोग करना होगा

मुझे नहीं पता कि यह लिस्टव्यू के साथ काम करेगा या नहीं, लेकिन RecyclerView के साथ काम करता है।

सांकेतिक टुकड़ा:

<android.support.v4.widget.NestedScrollView 
android:layout_width="match_parent"
android:layout_height="match_parent">

<android.support.v7.widget.RecyclerView
    android:layout_width="match_parent"
    android:layout_height="wrap_content" />

</android.support.v4.widget.NestedScrollView>
— शशांक काप्सिमे
स्रोत
कूल, मैंने इसकी कोशिश नहीं की है, इसलिए मैं यह पुष्टि नहीं कर सकता कि एक आंतरिक सूची दृश्य पतन नहीं करता है, लेकिन ऐसा लगता है कि यह इरादा हो सकता है। रोमेन गाइ को
— दोषपूर्ण
1
यह recyclerView के साथ काम करता है लेकिन listView के साथ नहीं। Thanx
— IgniteCoders
2

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

db = new dbhelper(this);

 cursor = db.dbCursor();
int count = cursor.getCount();
if (count > 0)
{    
LinearLayout linearLayout = (LinearLayout) findViewById(R.id.layoutId);
startManagingCursor(YOUR_CURSOR);

YOUR_ADAPTER(**or SimpleCursorAdapter **) adapter = new YOUR_ADAPTER(this,
    R.layout.itemLayout, cursor, arrayOrWhatever, R.id.textViewId,
    this.getApplication());

int i;
for (i = 0; i < count; i++){
  View listItem = adapter.getView(i,null,null);
  linearLayout.addView(listItem);
   }
}

नोट: यदि आप इसका उपयोग करते हैं, तो notifyDataSetChanged();उस उद्देश्य के अनुसार काम नहीं करेगा क्योंकि विचार फिर से नहीं किए जाएंगे। यदि आपको आस-पास कोई काम करने की आवश्यकता है, तो ऐसा करें

adapter.registerDataSetObserver(new DataSetObserver() {

            @Override
            public void onChanged() {
                super.onChanged();
                removeAndRedrawViews();

            }

        });
— PSchuette
स्रोत
2

स्क्रॉल दृश्य के अंदर एक सूची दृश्य का उपयोग करते समय दो मुद्दे हैं।

1- ListView को पूरी तरह से अपने बच्चों की ऊंचाई तक विस्तार करना चाहिए। यह सूची दृश्य इसे हल करें:

public class ListViewExpanded extends ListView
{
    public ListViewExpanded(Context context, AttributeSet attrs)
    {
        super(context, attrs);
        setDividerHeight(0);
    }

    @Override
    public void onMeasure(int widthMeasureSpec, int heightMeasureSpec)
    {
        super.onMeasure(widthMeasureSpec, MeasureSpec.makeMeasureSpec(Integer.MAX_VALUE >> 2, MeasureSpec.AT_MOST));
    }
}

डिवाइडर की ऊंचाई 0 होनी चाहिए, पंक्तियों में पैडिंग का उपयोग करें।

2- ListView स्पर्श की घटनाओं का उपभोग करता है इसलिए स्क्रॉलव्यू को हमेशा की तरह स्क्रॉल नहीं किया जा सकता है। यह स्क्रॉल दृश्य इस समस्या को हल करता है:

public class ScrollViewInterceptor extends ScrollView
{
    float startY;

    public ScrollViewInterceptor(Context context, AttributeSet attrs)
    {
        super(context, attrs);
    }

    @Override
    public boolean onInterceptTouchEvent(MotionEvent e)
    {
        onTouchEvent(e);
        if (e.getAction() == MotionEvent.ACTION_DOWN) startY = e.getY();
        return (e.getAction() == MotionEvent.ACTION_MOVE) && (Math.abs(startY - e.getY()) > 50);
    }
}

यह सबसे अच्छा तरीका है जो मैंने किया है!

— अली
स्रोत
2

एक समाधान जो मैं उपयोग कर रहा हूं, वह है स्क्रॉल दृश्य के सभी कंटेंट (सूची दृश्य के ऊपर और नीचे जो होना चाहिए) को जोड़ने के लिए सूची दृश्य में शीर्ष लेख और पाद लेख के रूप में।

तो यह काम करता है, यह भी कि यह कैसे किया जाना चाहिए अभिसरण बचाया जाता है।

— brokedid
स्रोत
1

विनय के कोड के लिए यहाँ धन्यवाद मेरे कोड के लिए है जब आपके पास स्क्रॉलव्यू के अंदर एक सूची नहीं हो सकती है फिर भी आपको ऐसा कुछ चाहिए

LayoutInflater li = LayoutInflater.from(this);

                RelativeLayout parent = (RelativeLayout) this.findViewById(R.id.relativeLayoutCliente);

                int recent = 0;

                for(Contatto contatto : contatti)
                {
                    View inflated_layout = li.inflate(R.layout.header_listview_contatti, layout, false);


                    inflated_layout.setId(contatto.getId());
                    ((TextView)inflated_layout.findViewById(R.id.textViewDescrizione)).setText(contatto.getDescrizione());
                    ((TextView)inflated_layout.findViewById(R.id.textViewIndirizzo)).setText(contatto.getIndirizzo());
                    ((TextView)inflated_layout.findViewById(R.id.textViewTelefono)).setText(contatto.getTelefono());
                    ((TextView)inflated_layout.findViewById(R.id.textViewMobile)).setText(contatto.getMobile());
                    ((TextView)inflated_layout.findViewById(R.id.textViewFax)).setText(contatto.getFax());
                    ((TextView)inflated_layout.findViewById(R.id.textViewEmail)).setText(contatto.getEmail());



                    RelativeLayout.LayoutParams relativeParams = new RelativeLayout.LayoutParams(LayoutParams.FILL_PARENT, LayoutParams.WRAP_CONTENT);

                    if (recent == 0)
                    {
                        relativeParams.addRule(RelativeLayout.BELOW, R.id.headerListViewContatti);
                    }
                    else
                    {
                        relativeParams.addRule(RelativeLayout.BELOW, recent);
                    }
                    recent = inflated_layout.getId();

                    inflated_layout.setLayoutParams(relativeParams);
                    //inflated_layout.setLayoutParams( new RelativeLayout.LayoutParams(source));

                    parent.addView(inflated_layout);
                }

रिश्तेदारलेआउट एक स्क्रॉल दृश्य के अंदर रहता है, इसलिए यह सभी स्क्रॉल करने योग्य हो जाता है :)

— max4ever
स्रोत
1

यहाँ @djunod के उत्तर पर छोटा संशोधन है कि मुझे इसे पूरी तरह से काम करने की आवश्यकता है:

public static void setListViewHeightBasedOnChildren(ListView listView)
{
    ListAdapter listAdapter = listView.getAdapter();
    if(listAdapter == null) return;
    if(listAdapter.getCount() <= 1) return;

    int desiredWidth = MeasureSpec.makeMeasureSpec(listView.getWidth(), MeasureSpec.AT_MOST);
    int totalHeight = 0;
    View view = null;
    for(int i = 0; i < listAdapter.getCount(); i++)
    {
        view = listAdapter.getView(i, view, listView);
        view.measure(desiredWidth, MeasureSpec.UNSPECIFIED);
        totalHeight += view.getMeasuredHeight();
    }
    ViewGroup.LayoutParams params = listView.getLayoutParams();
    params.height = totalHeight + (listView.getDividerHeight() * (listAdapter.getCount() - 1));
    listView.setLayoutParams(params);
    listView.requestLayout();
}
— Eng.Fouad
स्रोत
: हाय, आपका जवाब ज्यादातर समय काम करता है, लेकिन यह काम नहीं करता है अगर सूची में हेडर दृश्य और पैर दृश्य है। क्या आप इसे जांच सकते हैं?
— hguser
जब सूची-आइटम परिवर्तनशील आकार के होते हैं, तो मुझे एक समाधान की आवश्यकता होती है, यानी कुछ टेक्स्टव्यू जो कई लाइनों में विस्तारित होते हैं। कोई उपाय?
— खोबिब
1

यह कोशिश करो, यह मेरे लिए काम करता है, मैं भूल गया कि मुझे यह कहां मिला, कहीं स्टैक ओवरफ्लो में, मैं यहां यह नहीं समझाता कि यह काम क्यों नहीं करता है, लेकिन यह जवाब है :)।

    final ListView AturIsiPulsaDataIsiPulsa = (ListView) findViewById(R.id.listAturIsiPulsaDataIsiPulsa);
    AturIsiPulsaDataIsiPulsa.setOnTouchListener(new ListView.OnTouchListener() 
    {
        @Override
        public boolean onTouch(View v, MotionEvent event) 
        {
            int action = event.getAction();
            switch (action) 
            {
                case MotionEvent.ACTION_DOWN:
                // Disallow ScrollView to intercept touch events.
                v.getParent().requestDisallowInterceptTouchEvent(true);
                break;

                case MotionEvent.ACTION_UP:
                // Allow ScrollView to intercept touch events.
                v.getParent().requestDisallowInterceptTouchEvent(false);
                break;
            }

            // Handle ListView touch events.
            v.onTouchEvent(event);
            return true;
        }
    });
    AturIsiPulsaDataIsiPulsa.setClickable(true);
    AturIsiPulsaDataIsiPulsa.setAdapter(AturIsiPulsaDataIsiPulsaAdapter);

संपादित करें!, मुझे अंत में पता चला कि मुझे कोड कहां मिला है। यहाँ ! : स्क्रॉल दृश्य के अंदर सूची दृश्य Android पर स्क्रॉल नहीं कर रहा है

— Bhimbim
स्रोत
यह स्क्रॉलव्यू इंटरैक्शन को खोने से रोकने के लिए कैसे कवर करता है, लेकिन प्रश्न सूची के ऊंचाई को बनाए रखने के बारे में था।
— कार्ट गाड़ी
1

यद्यपि सुझाए गए सेटलिस्ट व्यूहाइटबेडऑनल्ड चिल्ड्रेन () विधियां ज्यादातर मामलों में काम करती हैं, कुछ मामलों में, विशेष रूप से बहुत सी वस्तुओं के साथ, मैंने देखा कि अंतिम तत्व प्रदर्शित नहीं होते हैं। इसलिए मैंने किसी भी एडॉप्टर कोड का पुन: उपयोग करने के लिए लिस्ट व्यू व्यवहार के एक सरल संस्करण की नकल करने का फैसला किया , यहाँ यह लिस्ट व्यू विकल्प है:

import android.content.Context;
import android.database.DataSetObserver;
import android.util.AttributeSet;
import android.util.Log;
import android.view.View;
import android.widget.LinearLayout;
import android.widget.ListAdapter;

public class StretchedListView extends LinearLayout {

private final DataSetObserver dataSetObserver;
private ListAdapter adapter;
private OnItemClickListener onItemClickListener;

public StretchedListView(Context context, AttributeSet attrs) {
    super(context, attrs);
    setOrientation(LinearLayout.VERTICAL);
    this.dataSetObserver = new DataSetObserver() {
        @Override
        public void onChanged() {
            syncDataFromAdapter();
            super.onChanged();
        }

        @Override
        public void onInvalidated() {
            syncDataFromAdapter();
            super.onInvalidated();
        }
    };
}

public void setAdapter(ListAdapter adapter) {
    ensureDataSetObserverIsUnregistered();

    this.adapter = adapter;
    if (this.adapter != null) {
        this.adapter.registerDataSetObserver(dataSetObserver);
    }
    syncDataFromAdapter();
}

protected void ensureDataSetObserverIsUnregistered() {
    if (this.adapter != null) {
        this.adapter.unregisterDataSetObserver(dataSetObserver);
    }
}

public Object getItemAtPosition(int position) {
    return adapter != null ? adapter.getItem(position) : null;
}

public void setSelection(int i) {
    getChildAt(i).setSelected(true);
}

public void setOnItemClickListener(OnItemClickListener onItemClickListener) {
    this.onItemClickListener = onItemClickListener;
}

public ListAdapter getAdapter() {
    return adapter;
}

public int getCount() {
    return adapter != null ? adapter.getCount() : 0;
}

private void syncDataFromAdapter() {
    removeAllViews();
    if (adapter != null) {
        int count = adapter.getCount();
        for (int i = 0; i < count; i++) {
            View view = adapter.getView(i, null, this);
            boolean enabled = adapter.isEnabled(i);
            if (enabled) {
                final int position = i;
                final long id = adapter.getItemId(position);
                view.setOnClickListener(new View.OnClickListener() {

                    @Override
                    public void onClick(View v) {
                        if (onItemClickListener != null) {
                            onItemClickListener.onItemClick(null, v, position, id);
                        }
                    }
                });
            }
            addView(view);

        }
    }
}
}
— अलिसियो कार्वाल्हो
स्रोत
1

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

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

class MyAdapter extends ArrayAdapter{

    public MyAdapter(Context context, int resource, List objects) {
        super(context, resource, objects);
    }

    @Override
    public View getView(int position, View convertView, ViewGroup parent) {
         ViewItem viewType = getItem(position);

        switch(viewType.type){
            case TEXTVIEW:
                convertView = layouteInflater.inflate(R.layout.textView1, parent, false);

                break;
            case LISTITEM:
                convertView = layouteInflater.inflate(R.layout.listItem, parent, false);

                break;            }


        return convertView;
    }


}

सूची एडॉप्टर सब कुछ संभाल सकता है क्योंकि यह केवल वही दिखाई देता है जो दिखाई देता है।

— TacoEater
स्रोत
0

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

यदि आप वास्तव में स्क्रॉल करना चाहते हैं तो एक और स्क्रॉलिंग दृश्य के अंदर एक सूची देखें इससे कोई फायदा नहीं होगा, लेकिन अन्यथा यह आपको कम से कम एक विचार देगा।

आपको उन सभी सामग्री को संयोजित करने के लिए एक कस्टम एडेप्टर बनाने की आवश्यकता है जिन्हें आप स्क्रॉल करना चाहते हैं और उस पर ListView के एडेप्टर को सेट करें।

मेरे पास सैंपल कोड काम नहीं है, लेकिन अगर आप ऐसा कुछ चाहते हैं।

<ListView/>

(other content)

<ListView/>

फिर आपको एक एडाप्टर बनाने की आवश्यकता है जो उस सभी सामग्री का प्रतिनिधित्व करता है। ListView / Adapters विभिन्न प्रकारों को संभालने के लिए काफी स्मार्ट हैं, लेकिन आपको एडॉप्टर स्वयं लिखने की आवश्यकता है।

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

— majinnaibu
स्रोत
0

जब हम ListViewअंदर होते हैं तो ScrollViewदो समस्याएं पैदा होती हैं। एक ScrollViewUNSPECIFIED मोड में अपने बच्चों को मापता है, इसलिए ListViewकेवल एक आइटम (मुझे पता नहीं क्यों) को समायोजित करने के लिए अपनी खुद की ऊंचाई सेट करता है, दूसरा ScrollViewस्पर्श घटना को स्वीकार करता हैListView करता है स्क्रॉल नहीं करता है।

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

— दुर्गादास एस
स्रोत
0

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

— Saksham
स्रोत
-1

यहां कोड का मेरा संस्करण है जो सूची दृश्य की कुल ऊंचाई की गणना करता है। यह एक मेरे लिए काम करता है:

   public static void setListViewHeightBasedOnChildren(ListView listView) {
    ListAdapter listAdapter = listView.getAdapter();
    if (listAdapter == null || listAdapter.getCount() < 2) {
        // pre-condition
        return;
    }

    int totalHeight = 0;
    int widthMeasureSpec = View.MeasureSpec.makeMeasureSpec(BCTDApp.getDisplaySize().width, View.MeasureSpec.AT_MOST);
    int heightMeasureSpec = View.MeasureSpec.makeMeasureSpec(0, View.MeasureSpec.UNSPECIFIED);
    ViewGroup.LayoutParams lp = new ViewGroup.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.WRAP_CONTENT);

    for (int i = 0; i < listAdapter.getCount(); i++) {
        View listItem = listAdapter.getView(i, null, listView);
        if (listItem instanceof ViewGroup) listItem.setLayoutParams(lp);
        listItem.measure(widthMeasureSpec, heightMeasureSpec);
        totalHeight += listItem.getMeasuredHeight();
    }

    totalHeight += listView.getPaddingTop() + listView.getPaddingBottom();
    totalHeight += (listView.getDividerHeight() * (listAdapter.getCount() - 1));
    ViewGroup.LayoutParams params = listView.getLayoutParams();
    params.height = totalHeight;
    listView.setLayoutParams(params);
    listView.requestLayout();
}
— myforums
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.