एंड्रॉइड: एक दृश्य के लिए कोई मैक्सहाइट क्यों नहीं है?

Question

देखें एक है minHeight किसी भी तरह की कमी है maxHeight:

मैं जो कुछ हासिल करने की कोशिश कर रहा हूं, उसमें कुछ आइटम (विचार) भरे हुए हैं ScrollView। जब 1..3 आइटम हैं तो मैं उन्हें सीधे प्रदर्शित करना चाहता हूं। मतलब हैScrollView 1, 2 या 3 आइटम की ऊंचाई है।

जब 4 या अधिक आइटम हैं, तो मैं चाहता हूं कि ScrollViewविस्तार (इस प्रकार maxHeight) बंद हो जाए और स्क्रॉल प्रदान करना शुरू करें।

हालांकि, दुर्भाग्य से सेट करने का कोई तरीका नहीं है maxHeight। इसलिए मुझे शायद अपनी ScrollViewऊँचाई को प्रोग्रामेटिक रूप से या तो WRAP_CONTENTतब सेट करना होगा जब 1..3 आइटम हों और ऊँचाई को 3*sizeOf(View)तब सेट करें जब 4 या अधिक आइटम हों।

क्या कोई समझा सकता है कि maxHeightजब कोई पहले से ही उपलब्ध नहीं है , तो क्यों नहीं minHeight?

(BTW: कुछ विचार, जैसे ImageViewएक maxHeightकार्यान्वित किया गया है।)

Comments

मैंने अन्य धागे में एक समाधान पोस्ट किया है: stackoverflow.com/questions/18425758/…

— JMPergar

मैंने इसके लिए chintanrathod.com/ ...

— Chintan Rathod

Google को हटाकर अधिकतम ऊंचाई कष्टप्रद और असुविधाजनक है। एक ही परिणाम प्राप्त करने के लिए अब आपको जो भी सामान करना है, उसे देखें।

— इयान वम्बाई

Answer 1

इनमें से किसी भी समाधान के लिए काम नहीं किया, जो मुझे चाहिए था जो कि एक स्क्रॉलव्यू था जिसे रैप_ कॉन्टेंट में सेट किया गया था, लेकिन एक मैक्सहाइट होने के कारण यह एक निश्चित बिंदु के बाद विस्तार करना बंद कर देगा और स्क्रॉल करना शुरू कर देगा। मैं बस स्क्रोल व्यू में ऑनमार्ट विधि को ओवररोड करता हूं।

@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
    heightMeasureSpec = MeasureSpec.makeMeasureSpec(300, MeasureSpec.AT_MOST);
    super.onMeasure(widthMeasureSpec, heightMeasureSpec);
}

यह सभी स्थितियों में काम नहीं कर सकता है, लेकिन यह निश्चित रूप से मुझे मेरे लेआउट के लिए आवश्यक परिणाम देता है। और यह मधु द्वारा टिप्पणी को भी संबोधित करता है।

यदि स्क्रॉलव्यू के नीचे कुछ लेआउट मौजूद है तो यह ट्रिक काम नहीं करेगी - मधु मार 5 बजे 4:36

Comments

यह काम कब नहीं होगा? यह एक बहुत साफ समाधान की तरह लगता है। मुझे आश्चर्य होता है कि उन्होंने इसे xml में लागू क्यों नहीं किया।

— क्रिस्टोफ स्मेट

यह संभवत: तब काम नहीं करेगा जब आप मैन्युअल रूप से 240 कहने के लिए ऊंचाई निर्धारित करते हैं। मैं स्क्रॉल मोड की जांच करने से परेशान नहीं था, क्योंकि मुझे केवल 1 विशिष्ट मोड (wra_content) का समर्थन करने की आवश्यकता थी।

— व्हिस्सल

इस उत्तर के लिए एक संपादन है जो कहता है कि 'यदि कुछ लेआउट स्क्रोलव्यू के नीचे मौजूद है तो यह ट्रिक काम नहीं करेगा', जो सच नहीं है। मेरे पास पृष्ठ के निचले भाग में एक लेआउट है और इस कस्टम लेआउट में "android: layout_above = '@ + ...'" है, जो हमेशा नीचे के लेआउट के ऊपर कस्टम लेआउट रखता है :)

— मशीन जनजाति

Answer 2

अधिकतम ScrollViewया ListViewअधिकतम के साथ बनाने के लिए आपको बस इसके चारों ओर एक पारदर्शी LinearLayout बनाने की आवश्यकता है, जो आप चाहते हैं कि अधिकतम ऊंचाई कितनी हो। आपने तब स्क्रॉलव्यू की ऊँचाई को निर्धारित किया है wrap_content। यह एक स्क्रॉलव्यू बनाता है जो तब तक बढ़ता दिखाई देता है जब तक कि इसकी ऊंचाई पैरेंट लीनियरयूट के बराबर न हो।

Comments

स्क्रॉलिंग सामग्री को स्क्रीन की पूरी ऊंचाई तक विस्तारित करने से रोकने के लिए यह उपयोगी था।

— काइल इवे

एक छोटे सुझाव के लिए एक रैखिक के बजाय एक फ्रेमलेयूट का उपयोग करना होगा, लेकिन मुझे संदेह है कि यह मायने रखता है।

— काइल इवे

यदि

— स्क्रॉलव्यू के

क्या आप कृपया कुछ कोड प्रदान कर सकते हैं? यह मेरे लिए काम नहीं करता था, इसलिए शायद मैं कुछ गलत कर रहा हूँ ...

— Android डेवलपर

यदि आपके पास इसके नीचे बटन हैं तो काम नहीं करेगा। यह स्क्रीन से बटन बंद कर देगा

— Li Tian Gong

Answer 3

इसने मुझे xml में अनुकूलन योग्य बनाने के लिए काम किया:

MaxHeightScrollView.java:

public class MaxHeightScrollView extends ScrollView {

private int maxHeight;
private final int defaultHeight = 200;

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

public MaxHeightScrollView(Context context, AttributeSet attrs) {
    super(context, attrs);
    if (!isInEditMode()) {
        init(context, attrs);
    }
}

public MaxHeightScrollView(Context context, AttributeSet attrs, int defStyleAttr) {
    super(context, attrs, defStyleAttr);
    if (!isInEditMode()) {
        init(context, attrs);
    }
}

@TargetApi(Build.VERSION_CODES.LOLLIPOP)
public MaxHeightScrollView(Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes) {
    super(context, attrs, defStyleAttr, defStyleRes);
    if (!isInEditMode()) {
        init(context, attrs);
    }
}

private void init(Context context, AttributeSet attrs) {
    if (attrs != null) {
        TypedArray styledAttrs = context.obtainStyledAttributes(attrs, R.styleable.MaxHeightScrollView);
        //200 is a defualt value
        maxHeight = styledAttrs.getDimensionPixelSize(R.styleable.MaxHeightScrollView_maxHeight, defaultHeight);

        styledAttrs.recycle();
    }
}

@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
    heightMeasureSpec = MeasureSpec.makeMeasureSpec(maxHeight, MeasureSpec.AT_MOST);
    super.onMeasure(widthMeasureSpec, heightMeasureSpec);
}
}

attr.xml

<declare-styleable name="MaxHeightScrollView">
        <attr name="maxHeight" format="dimension" />
    </declare-styleable>

उदाहरण लेआउट

<blah.blah.MaxHeightScrollView android:layout_weight="1"
                app:maxHeight="90dp"
                android:layout_width="fill_parent"
                android:layout_height="wrap_content">
                <EditText android:id="@+id/commentField"
                    android:hint="Say Something"
                    android:background="#FFFFFF"
                    android:paddingLeft="8dp"
                    android:paddingRight="8dp"
                    android:gravity="center_vertical"
                    android:maxLines="500"
                    android:minHeight="36dp"
                    android:layout_width="fill_parent"
                    android:layout_height="wrap_content" />
            </blah.blah.MaxHeightScrollView>

Comments

एक कस्टम दृश्य बनाना निश्चित रूप से इसे प्राप्त करने का सबसे अच्छा तरीका है।

— बर्ट्राम गिलफॉयल

और यह काम करता है अगर आपके पास स्क्रॉल दृश्य के नीचे लेआउट है! उत्तम!

— रागाइसिस

Answer 4

(मुझे पता है कि यह सीधे सवाल का जवाब नहीं देता है, लेकिन अधिकतम कार्यक्षमता की तलाश में दूसरों के लिए उपयोगी हो सकता है)

ConstraintLayout के माध्यम से अपने बच्चों के लिए अधिकतम ऊंचाई प्रदान करता है

app:layout_constraintHeight_max="300dp"
app:layout_constrainedHeight="true" 

या

app:layout_constraintWidth_max="300dp"
app:layout_constrainedWidth="true" 

यहाँ नमूना का उपयोग करें ।

Comments

यदि दृश्य एक ऊर्ध्वाधर श्रृंखला में है (

— कॉन्स्ट्रेन्थलाईट

जानकारी के लिए धन्यवाद।

— user1506104

Answer 5

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

@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
    if(MeasureSpec.getSize(heightMeasureSpec) > maxHeight) {
        heightMeasureSpec = MeasureSpec.makeMeasureSpec(maxHeight, MeasureSpec.AT_MOST);
    }
    super.onMeasure(widthMeasureSpec, heightMeasureSpec);
}

यह लेआउट को अधिकतम ऊंचाई से छोटा होने के लिए आकार देने की अनुमति देता है, लेकिन इसे अधिकतम ऊंचाई से बड़ा होने से भी रोकता है। मैंने इसका उपयोग एक लेआउट वर्ग के रूप में किया है जो ओवरराइड करता है RelativeLayoutऔर इसने मुझे एक कस्टम डायलॉग बनाने की अनुमति दी है ScrollViewक्योंकि उस का बच्चा MaxHeightRelativeLayoutस्क्रीन की पूरी ऊंचाई का विस्तार नहीं करता है और एंड्रॉइड के लिए मल्टी-विंडो में सबसे छोटे विधवा आकार में फिट होने के लिए सिकुड़ता है एन

Answer 6

मैक्सहाइट सेट करने का कोई तरीका नहीं है। लेकिन आप ऊँचाई निर्धारित कर सकते हैं।

ऐसा करने के लिए आपको स्क्रॉलव्यू के प्रत्येक आइटम की ऊंचाई की खोज करनी होगी। उसके बाद बस अपने स्क्रॉल दृश्य की ऊँचाई को संख्या संख्या * ऊंचाई पर सेट करें।

एक आइटम की ऊंचाई की खोज करने के लिए:

View item = adapter.getView(0, null, scrollView);
item.measure(0, 0);
int heightOfItem = item.getMeasuredHeight();

ऊंचाई निर्धारित करने के लिए:

// if the scrollView already has a layoutParams:
scrollView.getLayoutParams().height = heightOfItem * numberOfItens;
// or
// if the layoutParams is null, then create a new one.
scrollView.setLayoutParams(new LayoutParams(LayoutParams.FILL_PARENT, heightOfItem * numberOfItens));

Answer 7

अपने ScrollViewचारों ओर अपने सादे LinearLayoutको लेआउट_हाइट = "मैक्स_हाइट" के साथ लपेटें , यह एक आदर्श काम करेगा। वास्तव में, मेरे पास पिछले 5 वर्षों से शून्य मुद्दों के साथ उत्पादन में यह कोड है।

<LinearLayout
        android:id="@+id/subsParent"
        android:layout_width="match_parent"
        android:layout_height="150dp"
        android:gravity="bottom|center_horizontal"
        android:orientation="vertical">

        <ScrollView
            android:id="@+id/subsScroll"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_marginBottom="10dp"
            android:layout_marginEnd="15dp"
            android:layout_marginStart="15dp">

            <TextView
                android:id="@+id/subsTv"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:text="@string/longText"
                android:visibility="visible" />

        </ScrollView>
    </LinearLayout>

Comments

वास्तव में सही समाधान। चतुर और सरल। यह recyclerview के लिए भी उपयुक्त है।

— एलेक्स बेलेट्स

Answer 8

मेरा MaxHeightScrollViewकस्टम दृश्य

public class MaxHeightScrollView extends ScrollView {
    private int maxHeight;

    public MaxHeightScrollView(Context context) {
        this(context, null);
    }

    public MaxHeightScrollView(Context context, AttributeSet attrs) {
        this(context, attrs, 0);
    }

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

    private void init(Context context, AttributeSet attrs) {
        TypedArray styledAttrs =
                context.obtainStyledAttributes(attrs, R.styleable.MaxHeightScrollView);
        try {
            maxHeight = styledAttrs.getDimensionPixelSize(R.styleable.MaxHeightScrollView_mhs_maxHeight, 0);
        } finally {
            styledAttrs.recycle();
        }
    }

    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        if (maxHeight > 0) {
            heightMeasureSpec = MeasureSpec.makeMeasureSpec(maxHeight, MeasureSpec.AT_MOST);
        }
        super.onMeasure(widthMeasureSpec, heightMeasureSpec);
    }
}

style.xml

<declare-styleable name="MaxHeightScrollView">
    <attr name="mhs_maxHeight" format="dimension" />
</declare-styleable>

का उपयोग करते हुए

<....MaxHeightScrollView
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    app:mhs_maxHeight="100dp"
    >

    ...

</....MaxHeightScrollView>

Answer 9

मेरा यहाँ एक उत्तर है:

https://stackoverflow.com/a/29178364/1148784

बस एक नया वर्ग बनाएँ जो स्क्रॉलव्यू का विस्तार करता है और यह onMeasureविधि को ओवरराइड करता है ।

    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        if (maxHeight > 0){
            int hSize = MeasureSpec.getSize(heightMeasureSpec);
            int hMode = MeasureSpec.getMode(heightMeasureSpec);

            switch (hMode){
                case MeasureSpec.AT_MOST:
                    heightMeasureSpec = MeasureSpec.makeMeasureSpec(Math.min(hSize, maxHeight), MeasureSpec.AT_MOST);
                    break;
                case MeasureSpec.UNSPECIFIED:
                    heightMeasureSpec = MeasureSpec.makeMeasureSpec(maxHeight, MeasureSpec.AT_MOST);
                    break;
                case MeasureSpec.EXACTLY:
                    heightMeasureSpec = MeasureSpec.makeMeasureSpec(Math.min(hSize, maxHeight), MeasureSpec.EXACTLY);
                    break;
            }
        }

        super.onMeasure(widthMeasureSpec, heightMeasureSpec);
    }

Answer 10

जैसा कि ऊपर उल्लेख किया गया है, कांस्ट्रेनल लयआउट अपने बच्चों के लिए अधिकतम ऊंचाई प्रदान करता है:

app:layout_constraintHeight_max="300dp"
app:layout_constrainedHeight="true"

इसके अलावा, अगर एक चल रही है, जब तक एक बच्चे के लिए अधिकतम ऊंचाई, ऐप चलने तक अनिश्चित है, तब भी इस बच्चे को स्वचालित रूप से एक उत्परिवर्ती ऊंचाई को अनुकूलित करने का एक तरीका है, चाहे वह ऊर्ध्वाधर श्रृंखला में रखा गया हो।

उदाहरण के लिए, हमें एक परस्पर शीर्ष लेख TextView, एक उत्परिवर्ती स्क्रॉल दृश्य और एक उत्परिवर्ती पाद लेख TextView के साथ एक निचला संवाद दिखाने की आवश्यकता है। संवाद की अधिकतम ऊँचाई 320dp is होती है जब कुल ऊँचाई 320dp तक नहीं पहुँचती है स्क्रॉलदेखें wra_content के रूप में कार्य करते हैं, जब कुल ऊँचाई स्क्रॉलव्यू से अधिक हो जाती है "maxHeight = 320dp - शीर्ष लेख ऊँचाई - पाद ऊँचाई"।

हम इसे केवल xml लेआउट फ़ाइल के माध्यम से प्राप्त कर सकते हैं:

<?xml version="1.0" encoding="utf-8"?>
<android.support.constraint.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="320dp">

    <TextView
        android:id="@+id/tv_header"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:background="@color/black_10"
        android:gravity="center"
        android:padding="10dp"
        app:layout_constraintBottom_toTopOf="@id/scroll_view"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toTopOf="parent"
        app:layout_constraintVertical_bias="1"
        app:layout_constraintVertical_chainStyle="packed"
        tools:text="header" />

    <ScrollView
        android:id="@+id/scroll_view"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:background="@color/black_30"
        app:layout_constrainedHeight="true"
        app:layout_constraintBottom_toTopOf="@id/tv_footer"
        app:layout_constraintHeight_max="300dp"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toBottomOf="@id/tv_header">

        <LinearLayout
            android:id="@+id/ll_container"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:orientation="vertical">

            <TextView
                android:id="@+id/tv_sub1"
                android:layout_width="match_parent"
                android:layout_height="160dp"
                android:gravity="center"
                android:textColor="@color/orange_light"
                tools:text="sub1" />

            <TextView
                android:id="@+id/tv_sub2"
                android:layout_width="match_parent"
                android:layout_height="160dp"
                android:gravity="center"
                android:textColor="@color/orange_light"
                tools:text="sub2" />

        </LinearLayout>
    </ScrollView>

    <TextView
        android:id="@+id/tv_footer"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:background="@color/black_50"
        android:gravity="center"
        android:padding="10dp"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toBottomOf="@id/scroll_view"
        tools:text="footer" />
</android.support.constraint.ConstraintLayout>

अधिकांश आयात कोड छोटा है:

app:layout_constraintVertical_bias="1"
app:layout_constraintVertical_chainStyle="packed"

app:layout_constrainedHeight="true"

क्षैतिज अधिकतम अधिकतम उपयोग समान है।

Answer 11

क्या आपने लेआउट_वेट मूल्य का उपयोग करने की कोशिश की है ? यदि आप इसे 0 से अधिक मान पर सेट करते हैं, तो यह उस दृश्य को उपलब्ध शेष स्थान में फैला देगा।

यदि आपके पास कई विचार हैं जिन्हें विस्तारित करने की आवश्यकता है, तो मूल्य उनके बीच एक वजन बन जाएगा।

इसलिए यदि आपके पास दो विचार हैं जो दोनों लेआउट 1 के मान पर सेट हैं, तो वे दोनों अंतरिक्ष में भरने के लिए खिंचाव करेंगे, लेकिन वे दोनों अंतरिक्ष के बराबर मात्रा में खिंचाव करेंगे। यदि आप उनमें से एक को 2 के मान पर सेट करते हैं, तो यह दूसरे दृश्य के मुकाबले दोगुना खिंचाव होगा।

यहाँ कुछ और जानकारी रैखिक लेआउट के तहत सूचीबद्ध है।

Comments

वजन के साथ समस्या यह है कि वे रिश्तेदार हैं। विभिन्न स्क्रीन आकार, विभिन्न परिणाम, उदाहरण के लिए 800px स्क्रीन के साथ मैं एक निश्चित मूल्य पर एक वजन सेट कर सकता हूं, ताकि एक विशिष्ट क्षेत्र वांछित 200px के साथ समाप्त हो जाए। हालाँकि, 850px स्क्रीन के साथ विशिष्ट क्षेत्र 200px से बड़ा हो जाता है, लेकिन संलग्न तत्व अभी भी केवल 200px हैं। यही कारण है कि मैं एक है maxHeightजो मैं एक विशिष्ट डुबकी मूल्य पर सेट कर सकते हैं पसंद किया । (मैं अंत में

— क्रमिक रूप

Answer 12

मुझे लगता है कि यू सिर्फ 1 आइटम के लिए रनटाइम पर 3 या अधिक के scrollView.setHeight(200px)लिए 2 आइटम सेट कर सकता हैscrollView.setheight(400px)scrollView.setHeight(600px)

Comments

आप 'px' में आयाम सेट नहीं करना चाहते हैं। यह बहुत संभव है कि आपको कई डिवाइसेस पर इच्छित परिणाम न मिले। डेवलपर

— .android.com/guide

@HerndDerBeld कोड में काम करता है। यदि आप चाहें, तो आप हमेशा डीपी से पिक्सल में आसानी से परिवर्तित कर सकते हैं: फ्लोट पिक्सल = टाइप्डवैल्यू.प्पलीडिमेंशन (टाइप्डवैल्यू.COMPLEX_UNIT_DIP, dp, reference.getResources () (.getDisplayMetrics ());

— Android डेवलपर

Answer 13

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

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

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

btw। minHeight की गारंटी नहीं है (और शायद मौजूद भी नहीं होनी चाहिए)। वस्तुओं को देखने के लिए मजबूर करने के लिए इसका कुछ लाभ हो सकता है जबकि अन्य रिश्तेदार आइटम छोटे हो जाते हैं।

Comments

ये गलत है। इस तर्क के द्वारा, आप Android: layout_width = "500dp" या तो नहीं कह पाएंगे।

— ग्लेन मेनार्ड

मैं नहीं देखता कि क्या गलत होना चाहिए और न ही आपकी तर्क व्याख्या। यदि आप लेआउट (एक्सपोज़र सेट करते हैं) 500dp शायद एक उपकरण को उपयुक्त लगे, दूसरे पर नहीं। लेआउट प्रबंधकों ftw! हो सकता है कि आप अधिक परेशान नीचे वोट परेशान देख :)

— डिएगो Frehner

यह केवल एंड्रॉइड कहने के लिए वैध है: maxWidth = "500dp" Android के रूप में कहने के लिए: लेआउट_प्रकार = "500dp"। वे दोनों दृश्य पर विशिष्ट आयामों को लागू करते हैं।

— ग्लेन मेनार्ड

Answer 14

अगर कोई भी LayoutParams उदाहरण के लिए सटीक मान का उपयोग करने पर विचार कर रहा है

setLayoutParams(new LayoutParams(Y, X );

उपकरण प्रदर्शन के घनत्व को ध्यान में रखना याद रखें अन्यथा आपको विभिन्न उपकरणों पर बहुत ही अजीब व्यवहार हो सकता है। उदाहरण के लिए:

Display display = getWindowManager().getDefaultDisplay();
DisplayMetrics d = new DisplayMetrics();
display.getMetrics(d);
setLayoutParams(new LayoutParams(LayoutParams.WRAP_CONTENT, (int)(50*d.density) ));

Answer 15

पहले पिक्सेल में आइटम की ऊँचाई प्राप्त करें

View rowItem = adapter.getView(0, null, scrollView);   
rowItem.measure(0, 0);    
int heightOfItem = rowItem.getMeasuredHeight();

तो बस

Display display = getWindowManager().getDefaultDisplay();    
DisplayMetrics displayMetrics = new DisplayMetrics();    
display.getMetrics(displayMetrics);    
scrollView.getLayoutParams().height = (int)((heightOfItem * 3)*displayMetrics .density);

Answer 16

यदि आप लोग एक गैर-अतिप्रवाह स्क्रॉलव्यू या सूची-क्रम बनाना चाहते हैं, तो बस एक RelativeLayout पर, इसके लिए ऊपर और नीचे के शीर्ष-तल पर और नीचे के साथ:

<ScrollView
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:layout_above="@+id/topview"
    android:layout_below="@+id/bottomview" >

Comments

इसके लिए और क्रेडिट की जरूरत है। विशिष्ट लेकिन सरल कार्यान्वयन।

— ल्यूक एलीसन

Answer 17

मैंने कोटलिन में बने एक कस्टम स्क्रॉलव्यू का उपयोग किया है जो उपयोग करता है maxHeight। उपयोग का उदाहरण:

<com.antena3.atresplayer.tv.ui.widget.ScrollViewWithMaxHeight
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:maxHeight="100dp">

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

        <TextView
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"/>
</com.antena3.atresplayer.tv.ui.widget.ScrollViewWithMaxHeight>

यहाँ का कोड है ScrollViewWidthMaxHeight:

import android.content.Context
import android.util.AttributeSet
import android.widget.ScrollView
import timber.log.Timber

class ScrollViewWithMaxHeight @JvmOverloads constructor(
    context: Context,
    attrs: AttributeSet? = null,
    defStyleAttr: Int = 0
) : ScrollView(context, attrs, defStyleAttr) {

companion object {
    var WITHOUT_MAX_HEIGHT_VALUE = -1
}

private var maxHeight = WITHOUT_MAX_HEIGHT_VALUE

init {
    val a = context.obtainStyledAttributes(
        attrs, R.styleable.ScrollViewWithMaxHeight,
        defStyleAttr, 0
    )
    try {
        maxHeight = a.getDimension(
            R.styleable.ScrollViewWithMaxHeight_android_maxHeight,
            WITHOUT_MAX_HEIGHT_VALUE.toFloat()
        ).toInt()
    } finally {
        a.recycle()
    }
}

override fun onMeasure(widthMeasureSpec: Int, heightMeasureSpec: Int) {
    var heightMeasure = heightMeasureSpec
    try {
        var heightSize = MeasureSpec.getSize(heightMeasureSpec)
        if (maxHeight != WITHOUT_MAX_HEIGHT_VALUE) {
            heightSize = maxHeight
            heightMeasure = MeasureSpec.makeMeasureSpec(heightSize, MeasureSpec.AT_MOST)
        } else {
            heightMeasure = MeasureSpec.makeMeasureSpec(heightSize, MeasureSpec.UNSPECIFIED)
        }
        layoutParams.height = heightSize
    } catch (e: Exception) {
        Timber.e(e, "Error forcing height")
    } finally {
        super.onMeasure(widthMeasureSpec, heightMeasure)
    }
}

fun setMaxHeight(maxHeight: Int) {
    this.maxHeight = maxHeight
}
}

जिसमें इस घोषणा की भी जरूरत है values/attrs.xml:

<?xml version="1.0" encoding="utf-8"?>
<resources>
<declare-styleable name="ScrollViewWithMaxHeight">
        <attr name="android:maxHeight" />
    </declare-styleable>
</resources>