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


176

मेरे पास एक एप्लिकेशन है जो पुस्तकों के संग्रह (जैसे प्लेलिस्ट) का प्रबंधन करता है।

मैं एक ऊर्ध्वाधर पुनर्नवीनीकरण दृश्य के साथ संग्रह की एक सूची प्रदर्शित करना चाहता हूं और प्रत्येक पंक्ति के अंदर, क्षैतिज पुनर्नवीनीकरण दृश्य में पुस्तक की एक सूची।

जब मैं आंतरिक क्षैतिज पुनर्नवीकरण के लेआउट_ को 300dp पर सेट करता हूं, तो इसे सही ढंग से प्रदर्शित किया जाता है, लेकिन जब मैं इसे wra_content पर सेट करता हूं, तो यह कुछ भी प्रदर्शित नहीं करता है। मुझे wra_content का उपयोग करने की आवश्यकता है क्योंकि मैं ऊर्ध्वाधर और क्षैतिज प्रदर्शन के बीच स्विच करने के लिए प्रोग्रामेटिक रूप से लेआउट प्रबंधक को बदलने में सक्षम होना चाहता हूं।

यहां छवि विवरण दर्ज करें

क्या आप जानते हैं कि मैं क्या गलत कर रहा हूँ?

मेरा टुकड़ा लेआउट:

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
                android:layout_width="match_parent"
                android:layout_height="match_parent"
                android:background="@color/white">

    <com.twibit.ui.view.CustomSwipeToRefreshLayout
        android:id="@+id/swipe_container"
        android:layout_width="match_parent"
        android:layout_height="match_parent">

        <LinearLayout
            android:layout_width="match_parent"
            android:layout_height="match_parent"
            android:orientation="vertical">

            <android.support.v7.widget.RecyclerView
                android:id="@+id/shelf_collection_listview"
                android:layout_width="match_parent"
                android:layout_height="match_parent"
                android:paddingTop="10dp"/>

        </LinearLayout>

    </com.twibit.ui.view.CustomSwipeToRefreshLayout>
</LinearLayout>

संग्रह तत्व लेआउट:

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

    <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
                    android:layout_width="match_parent"
                    android:layout_height="wrap_content"
                    android:background="#FFF">

        <!-- Simple Header -->

    </RelativeLayout>

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

        <TextView
            android:layout_width="match_parent"
            android:layout_height="match_parent"
            android:text="@string/empty_collection"
            android:id="@+id/empty_collection_tv"
            android:visibility="gone"
            android:gravity="center"/>

        <android.support.v7.widget.RecyclerView
            android:id="@+id/collection_book_listview"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"/> <!-- android:layout_height="300dp" -->

    </FrameLayout>

</LinearLayout>

पुस्तक सूची आइटम:

<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
              android:layout_width="180dp"
              android:layout_height="220dp"
              android:layout_gravity="center">

        <ImageView
            android:id="@+id/shelf_item_cover"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_gravity="center"
            android:maxWidth="150dp"
            android:maxHeight="200dp"
            android:src="@drawable/placeholder"
            android:contentDescription="@string/cover"
            android:adjustViewBounds="true"
            android:background="@android:drawable/dialog_holo_light_frame"/>

</FrameLayout>

यहाँ मेरा संग्रह अनुकूलक है:

private class CollectionsListAdapter extends RecyclerView.Adapter<CollectionsListAdapter.ViewHolder> {
    private final String TAG = CollectionsListAdapter.class.getSimpleName();
    private Context mContext;

    // Create the ViewHolder class to keep references to your views
    class ViewHolder extends RecyclerView.ViewHolder {

        private final TextView mHeaderTitleTextView;
        private final TextView mHeaderCountTextView;

        private final RecyclerView mHorizontalListView;
        private final TextView mEmptyTextView;

        public ViewHolder(View view) {
            super(view);

            mHeaderTitleTextView = (TextView) view.findViewById(R.id.collection_header_tv);
            mHeaderCountTextView = (TextView) view.findViewById(R.id.collection_header_count_tv);

            mHorizontalListView = (RecyclerView) view.findViewById(R.id.collection_book_listview);
            mEmptyTextView = (TextView) view.findViewById(R.id.empty_collection_tv);
        }
    }


    public CollectionsListAdapter(Context context) {
        mContext = context;
    }


    @Override
    public ViewHolder onCreateViewHolder(ViewGroup parent, int i) {
        Log.d(TAG, "CollectionsListAdapter.onCreateViewHolder(" + parent.getId() + ", " + i + ")");
        // Create a new view by inflating the row item xml.
        View v = LayoutInflater.from(parent.getContext()).inflate(R.layout.shelf_collection, parent, false);

        // Set the view to the ViewHolder
        ViewHolder holder = new ViewHolder(v);

        holder.mHorizontalListView.setHasFixedSize(false);
        holder.mHorizontalListView.setHorizontalScrollBarEnabled(true);

        // use a linear layout manager
        LinearLayoutManager mLayoutManager = new LinearLayoutManager(mContext);
        mLayoutManager.setOrientation(LinearLayoutManager.HORIZONTAL);
        holder.mHorizontalListView.setLayoutManager(mLayoutManager);

        return holder;
    }

    @Override
    public void onBindViewHolder(ViewHolder holder, int i) {
        Log.d(TAG, "CollectionsListAdapter.onBindViewHolder(" + holder.getPosition() + ", " + i + ")");

        Collection collection = mCollectionList.get(i);
        Log.d(TAG, "Collection : " + collection.getLabel());

        holder.mHeaderTitleTextView.setText(collection.getLabel());
        holder.mHeaderCountTextView.setText("" + collection.getBooks().size());

        // Create an adapter if none exists
        if (!mBookListAdapterMap.containsKey(collection.getCollectionId())) {
            mBookListAdapterMap.put(collection.getCollectionId(), new BookListAdapter(getActivity(), collection));
        }

        holder.mHorizontalListView.setAdapter(mBookListAdapterMap.get(collection.getCollectionId()));

    }

    @Override
    public int getItemCount() {
        return mCollectionList.size();
    }
}

और अंत में, पुस्तक एडाप्टर:

private class BookListAdapter extends RecyclerView.Adapter<BookListAdapter.ViewHolder> implements View.OnClickListener {
    private final String TAG = BookListAdapter.class.getSimpleName();

    // Create the ViewHolder class to keep references to your views
    class ViewHolder extends RecyclerView.ViewHolder {
        public ImageView mCoverImageView;

        public ViewHolder(View view) {
            super(view);
            mCoverImageView = (ImageView) view.findViewById(R.id.shelf_item_cover);
        }
    }

    @Override
    public void onClick(View v) {
        BookListAdapter.ViewHolder holder = (BookListAdapter.ViewHolder) v.getTag();
        int position = holder.getPosition();
        final Book book = mCollection.getBooks().get(position);

        // Click on cover image
        if (v.getId() == holder.mCoverImageView.getId()) {
            downloadOrOpenBook(book);
            return;
        }
    }

    private void downloadOrOpenBook(final Book book) {
        // do stuff
    }

    private Context mContext;
    private Collection mCollection;

    public BookListAdapter(Context context, Collection collection) {
        Log.d(TAG, "BookListAdapter(" + context + ", " + collection + ")");
        mCollection = collection;
        mContext = context;
    }

    @Override
    public ViewHolder onCreateViewHolder(ViewGroup parent, int i) {
        Log.d(TAG, "onCreateViewHolder(" + parent.getId() + ", " + i + ")");
        // Create a new view by inflating the row item xml.
        View v = LayoutInflater.from(parent.getContext()).inflate(R.layout.shelf_grid_item, parent, false);

        // Set the view to the ViewHolder
        ViewHolder holder = new ViewHolder(v);
        holder.mCoverImageView.setOnClickListener(BookListAdapter.this); // Download or Open

        holder.mCoverImageView.setTag(holder);

        return holder;
    }

    @Override
    public void onBindViewHolder(ViewHolder holder, int i) {
        Log.d(TAG, "onBindViewHolder(" + holder.getPosition() + ", " + i + ")");

        Book book = mCollection.getBooks().get(i);

        ImageView imageView = holder.mCoverImageView;
        ImageLoader.getInstance().displayImage(book.getCoverUrl(), imageView);
    }

    @Override
    public int getItemCount() {
        return mCollection.getBooks().size();
    }
}

ऊर्ध्वाधर और क्षैतिज के बीच लेआउटमैन बदलने के लिए आपको wra_content का उपयोग करने की आवश्यकता क्यों है?
AmaJayJB

1
यदि मैं एक विशिष्ट मान के लिए layout_height सेट करता हूं (क्षैतिज लेआउट प्रबंधक के लिए एक तत्व की ऊंचाई बताता है), यह केवल ऊर्ध्वाधर लेआउट प्रबंधक के साथ सूची की पहली पंक्ति प्रदर्शित करता है।
ट्विबिट

लेकिन recyclerView में एक स्क्रॉल दृश्य बनाया गया है, जिससे आप केवल आइटम के माध्यम से स्क्रॉल कर सकते हैं ... या क्या मैं यहां बिंदु याद कर रहा हूं? क्षमा करें समझने की कोशिश कर रहा हूँ
AmaJayJB

मैं संग्रह वस्तुओं के माध्यम से स्क्रॉल करना चाहता हूं लेकिन आंतरिक पुस्तक सूची (क्षैतिज को छोड़कर) नहीं। एक्सपेंडेबलिस्टव्यू जैसा कुछ।
टि्वबिट

2
मैं आपके साथ एक ही सवाल का सामना कर रहा हूं, क्या आपने अभी हल किया है?
विंसस्टलिंग

जवाबों:


46

अपडेट करें

संस्करण 23.2.0 में इस सुविधा से संबंधित कई मुद्दों को 23.2.1 में तय किया गया है, इसके बजाय इसे अपडेट करें।

समर्थन लाइब्रेरी संस्करण 23.2 की रिलीज़ के साथ, RecyclerViewअब इसका समर्थन करता है!

इसे अपडेट build.gradleकरें:

compile 'com.android.support:recyclerview-v7:23.2.1'

या उस से परे किसी भी संस्करण।

यह रिलीज़ लेआउटमैनेजर एपीआई के लिए एक रोमांचक नई सुविधा लाता है: ऑटो-माप! यह एक RecyclerView को अपनी सामग्री के आकार के आधार पर खुद को आकार देने की अनुमति देता है। इसका अर्थ है कि पहले अनुपलब्ध परिदृश्य, जैसे कि पुनर्नवीकरण दृश्य के आयाम के लिए WRAP_CONTENT का उपयोग करना, अब संभव है। अब आप सभी लेआउटप्रबंधन में निर्मित पाएंगे जो अब ऑटो-माप का समर्थन करते हैं।

setAutoMeasurementEnabled()यदि आवश्यक हो तो इसे निष्क्रिय किया जा सकता है। विस्तार से जाँच करें यहाँ


4
सावधान रहे! यहाँ नए कीड़े हैं: stackoverflow.com/questions/35619022/…
डेनिस नेक

क्या यह बग के ऊपर पता है?
razzledazzle

1
यह ठीक से काम नहीं कर रहा है हमेशा प्रत्येक आइटम के बीच रिक्त स्थान देखा गया है
RAHULRSANNIDHI

2
कृपया माता-पिता के लेआउट की ऊँचाई से सावधान रहें जिसमें बाल पुनर्नवीनीकरण दृश्य सम्‍मिलित होना चाहिए।
RAHULRSANNIDHI

2
23.2.1RecyclerView के संस्करण में कई बग्स तय हो गए हैं। हमारे लिए बहुत अच्छा काम करता है। यदि नहीं, तो तुम भी साथ की कोशिश कर सकते24.0.0-alpha1
जोकिन Iurchuk

124

@ user2302510 समाधान उतना अच्छा काम नहीं करता जितना आप उम्मीद कर सकते हैं। अभिविन्यास और गतिशील रूप से डेटा परिवर्तन दोनों के लिए पूर्ण वर्कअराउंड है:

public class MyLinearLayoutManager extends LinearLayoutManager {

    public MyLinearLayoutManager(Context context, int orientation, boolean reverseLayout)    {
        super(context, orientation, reverseLayout);
    }

    private int[] mMeasuredDimension = new int[2];

    @Override
    public void onMeasure(RecyclerView.Recycler recycler, RecyclerView.State state,
                          int widthSpec, int heightSpec) {
        final int widthMode = View.MeasureSpec.getMode(widthSpec);
        final int heightMode = View.MeasureSpec.getMode(heightSpec);
        final int widthSize = View.MeasureSpec.getSize(widthSpec);
        final int heightSize = View.MeasureSpec.getSize(heightSpec);
        int width = 0;
        int height = 0;
        for (int i = 0; i < getItemCount(); i++) {
            measureScrapChild(recycler, i,
                    View.MeasureSpec.makeMeasureSpec(i, View.MeasureSpec.UNSPECIFIED),
                    View.MeasureSpec.makeMeasureSpec(i, View.MeasureSpec.UNSPECIFIED),
                    mMeasuredDimension);

            if (getOrientation() == HORIZONTAL) {
                width = width + mMeasuredDimension[0];
                if (i == 0) {
                    height = mMeasuredDimension[1];
                }
            } else {
                height = height + mMeasuredDimension[1];
                if (i == 0) {
                    width = mMeasuredDimension[0];
                }
            }
        }
        switch (widthMode) {
            case View.MeasureSpec.EXACTLY:
                width = widthSize;
            case View.MeasureSpec.AT_MOST:
            case View.MeasureSpec.UNSPECIFIED:
        }

        switch (heightMode) {
            case View.MeasureSpec.EXACTLY:
                height = heightSize;
            case View.MeasureSpec.AT_MOST:
            case View.MeasureSpec.UNSPECIFIED:
        }

        setMeasuredDimension(width, height);
    }

    private void measureScrapChild(RecyclerView.Recycler recycler, int position, int widthSpec,
                                   int heightSpec, int[] measuredDimension) {
        View view = recycler.getViewForPosition(position);
        if (view != null) {
            RecyclerView.LayoutParams p = (RecyclerView.LayoutParams) view.getLayoutParams();
            int childWidthSpec = ViewGroup.getChildMeasureSpec(widthSpec,
                    getPaddingLeft() + getPaddingRight(), p.width);
            int childHeightSpec = ViewGroup.getChildMeasureSpec(heightSpec,
                    getPaddingTop() + getPaddingBottom(), p.height);
            view.measure(childWidthSpec, childHeightSpec);
            measuredDimension[0] = view.getMeasuredWidth() + p.leftMargin + p.rightMargin;
            measuredDimension[1] = view.getMeasuredHeight() + p.bottomMargin + p.topMargin;
            recycler.recycleView(view);
        }
    }
}

3
आपका समाधान काफी अच्छी तरह से काम करता है लेकिन आइटमडेक्यूलेशन (जैसे विभाजक) को ध्यान में नहीं रखता है।
Twibit

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

1
यह सामग्री परिवर्तन एनिमेशन के साथ काम नहीं करता है - सुचारू रूप से बढ़ता / सिकुड़ने के बजाय रिसाइक्लेव्यू स्नैप का आकार।
zyamys

36
यहाँ कक्षा का एक परिष्कृत संस्करण है जो काम करता है और समस्याओं का अभाव है अन्य समाधान हैं: github.com/sero/android-linear-layout-manager/blob/master/lib/…
se.solovitv

2
मैं स्क्रॉल के अंदर इस recyclerview का उपयोग कर रहा हूं और इस कोड का उपयोग करके recylerview रैप कंटेंट बना रहा हूं। लेकिन स्क्रॉलिंग स्क्रॉलव्यू सुचारू नहीं है। समाधान stackoverflow.com/a/32283439/3736955 है
Jemshit Iskenderov

39

जब आपके आइटम को "wra_content" बनाने की आवश्यकता होती है, तो ऊपर का कोड अच्छी तरह से काम नहीं करता है, क्योंकि यह दोनों आइटमों की ऊंचाई और चौड़ाई को मापने के लिए उपाय करता है। कुछ परेशानियों के बाद मैंने उस समाधान को संशोधित किया है ताकि अब आइटम का विस्तार हो सके। अंतर केवल इतना है कि यह माता-पिता को ऊंचाई या चौड़ाई प्रदान करता है। मापक लेआउट लेआउट पर निर्भर करता है।

public class MyLinearLayoutManager extends LinearLayoutManager {

public MyLinearLayoutManager(Context context, int orientation, boolean reverseLayout)    {
    super(context, orientation, reverseLayout);
}

private int[] mMeasuredDimension = new int[2];

@Override
public void onMeasure(RecyclerView.Recycler recycler, RecyclerView.State state,
                      int widthSpec, int heightSpec) {
    final int widthMode = View.MeasureSpec.getMode(widthSpec);
    final int heightMode = View.MeasureSpec.getMode(heightSpec);
    final int widthSize = View.MeasureSpec.getSize(widthSpec);
    final int heightSize = View.MeasureSpec.getSize(heightSpec);
    int width = 0;
    int height = 0;
    for (int i = 0; i < getItemCount(); i++) {


        if (getOrientation() == HORIZONTAL) {

            measureScrapChild(recycler, i,
                    View.MeasureSpec.makeMeasureSpec(i, View.MeasureSpec.UNSPECIFIED),
                    heightSpec,
                    mMeasuredDimension);

            width = width + mMeasuredDimension[0];
            if (i == 0) {
                height = mMeasuredDimension[1];
            }
        } else {
            measureScrapChild(recycler, i,
                    widthSpec,
                    View.MeasureSpec.makeMeasureSpec(i, View.MeasureSpec.UNSPECIFIED),
                    mMeasuredDimension);
            height = height + mMeasuredDimension[1];
            if (i == 0) {
                width = mMeasuredDimension[0];
            }
        }
    }
    switch (widthMode) {
        case View.MeasureSpec.EXACTLY:
            width = widthSize;
        case View.MeasureSpec.AT_MOST:
        case View.MeasureSpec.UNSPECIFIED:
    }

    switch (heightMode) {
        case View.MeasureSpec.EXACTLY:
            height = heightSize;
        case View.MeasureSpec.AT_MOST:
        case View.MeasureSpec.UNSPECIFIED:
    }

    setMeasuredDimension(width, height);
}

private void measureScrapChild(RecyclerView.Recycler recycler, int position, int widthSpec,
                               int heightSpec, int[] measuredDimension) {
    View view = recycler.getViewForPosition(position);
    recycler.bindViewToPosition(view, position);
    if (view != null) {
        RecyclerView.LayoutParams p = (RecyclerView.LayoutParams) view.getLayoutParams();
        int childWidthSpec = ViewGroup.getChildMeasureSpec(widthSpec,
                getPaddingLeft() + getPaddingRight(), p.width);
        int childHeightSpec = ViewGroup.getChildMeasureSpec(heightSpec,
                getPaddingTop() + getPaddingBottom(), p.height);
        view.measure(childWidthSpec, childHeightSpec);
        measuredDimension[0] = view.getMeasuredWidth() + p.leftMargin + p.rightMargin;
        measuredDimension[1] = view.getMeasuredHeight() + p.bottomMargin + p.topMargin;
        recycler.recycleView(view);
    }
}
}

धन्यवाद! इस समाधान ने मेरे लिए सबसे अच्छा काम किया है। डेनिस को पर्याप्त माप नहीं लगता था और दृश्य अभी भी स्क्रॉल करने योग्य था। एक भी बच्चा होने पर सिनान केवल ठीक व्यवहार करते दिखाई दिए। नोट: मेरे बच्चे के विचारों का इस्तेमाल किया गया हैwrap_content
कासिम

स्क्रॉल करने में सक्षम करने के लिए जब यह दृश्य माता-पिता की सीमा से switch (heightMode) { case View.MeasureSpec.AT_MOST: if (height < heightSize) break; case View.MeasureSpec.EXACTLY: height = heightSize; case View.MeasureSpec.UNSPECIFIED: }
टकराता है

उत्कृष्ट समाधान। यह पूरी तरह से काम किया। साइड नोट पर, एक कंस्ट्रक्टर का उपयोग करने के बजाय, मैंने बस एक निजी इंस्टेंस चर और एक सेटर / गेट्टर विधि को एक कॉन्स्टेंट अंतिम इंट ओरेंटेशन के साथ बनाया (बस अगर किसी और को कोई समस्या हो रही है) और उसके बाद उत्तीर्ण अभिविन्यास की जांच करने के लिए इसका उपयोग किया ।
PGMacDesign

1
मैंने लॉलीपॉप और इसके बाद के संस्करण पर समस्या से टकराया है, जब आप पुनर्नवीकरण से ऊपर स्क्रॉल करने का प्रयास करते हैं तो RecyclerView गलत तरीके से काम करता है (कोई फ़्लिंग नहीं है)। इस समस्या को हल करने के लिए आपको NotScrollableRecyclerView (कस्टम) बनाने की ज़रूरत है और onInceptceptTouchEvent, onTouchEvent तरीकों को ओवरराइड करें और उनमें से सुपर कार्यान्वयन को न कहने के लिए और आपको दोनों तरीकों से गलत वापस करना चाहिए।
अल्ट्रा जूल

यह काम करता है, लेकिन मुझे समझ में नहीं आता कि यह इतना अनावश्यक रूप से जटिल क्यों है कि इसके बच्चों की ऊंचाई की गणना के बाद ही इसकी ऊंचाई मापी जाती है ...
जो मैहर

22

मौजूदा लेआउट प्रबंधक अभी तक रैप सामग्री का समर्थन नहीं करता है।

आप एक नया LayoutManager बना सकते हैं जो मौजूदा एक को बढ़ाता है और रैप सामग्री के लिए मापने के लिए onMeasure विधि को ओवरराइड करता है।


1
यह वह नहीं है जिसकी मैंने अपेक्षा की थी लेकिन यह सच प्रतीत होता है। देखें: RecyclerView.LayoutManager & LinearLayoutManager
Twibit

@ yiit, क्या recyclerView डिफ़ॉल्ट रूप से रैप कंटेंट को सपोर्ट करेगा?
सिनान कोज़ाक

3
यह लेआउटमैकेजर पर निर्भर करता है न कि रिसायकलर व्यू पर। यह हमारे रोडमैप में है।
यिगित

@yigit क्या यह setHasFixedSize(boolean)डिफ़ॉल्ट लेआउट प्रबंधकों के साथ अनुपयोगी नहीं है ? वैसे भी, यह जानने के लिए बढ़िया है कि यह रोडमैप पर है। आशा है कि यह जल्द ही सामने आएगा।
goncalossilva

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

22

जैसा कि @ yiit ने उल्लेख किया है, आपको ऑनमार्ट () को ओवरराइड करने की आवश्यकता है। @ User2302510 और @DenisNek दोनों के पास अच्छे उत्तर हैं, लेकिन यदि आप ItemDecoration का समर्थन करना चाहते हैं, तो आप इस कस्टम लेआउट प्रबंधक का उपयोग कर सकते हैं।

हालांकि अन्य उत्तर स्क्रॉल नहीं कर सकते हैं जब स्क्रीन पर प्रदर्शित होने की तुलना में अधिक आइटम हैं। जब यह स्क्रीन आकार की तुलना में अधिक आइटम हैं, तो यह onMeasure () के डिफ़ॉल्ट इम्प्लिमेंटेशन का उपयोग कर रहा है।

public class MyLinearLayoutManager extends LinearLayoutManager {

public MyLinearLayoutManager(Context context, int orientation, boolean reverseLayout)    {
    super(context, orientation, reverseLayout);
}

private int[] mMeasuredDimension = new int[2];

@Override
public void onMeasure(RecyclerView.Recycler recycler, RecyclerView.State state,
                      int widthSpec, int heightSpec) {
    final int widthMode = View.MeasureSpec.getMode(widthSpec);
    final int heightMode = View.MeasureSpec.getMode(heightSpec);
    final int widthSize = View.MeasureSpec.getSize(widthSpec);
    final int heightSize = View.MeasureSpec.getSize(heightSpec);
    int width = 0;
    int height = 0;
    for (int i = 0; i < getItemCount(); i++) {
        measureScrapChild(recycler, i,
                View.MeasureSpec.makeMeasureSpec(i, View.MeasureSpec.UNSPECIFIED),
                View.MeasureSpec.makeMeasureSpec(i, View.MeasureSpec.UNSPECIFIED),
                mMeasuredDimension);

        if (getOrientation() == HORIZONTAL) {
            width = width + mMeasuredDimension[0];
            if (i == 0) {
                height = mMeasuredDimension[1];
            }
        } else {
            height = height + mMeasuredDimension[1];
            if (i == 0) {
                width = mMeasuredDimension[0];
            }
        }
    }

    // If child view is more than screen size, there is no need to make it wrap content. We can use original onMeasure() so we can scroll view.
    if (height < heightSize && width < widthSize) {

        switch (widthMode) {
            case View.MeasureSpec.EXACTLY:
                width = widthSize;
            case View.MeasureSpec.AT_MOST:
            case View.MeasureSpec.UNSPECIFIED:
        }

        switch (heightMode) {
            case View.MeasureSpec.EXACTLY:
                height = heightSize;
            case View.MeasureSpec.AT_MOST:
            case View.MeasureSpec.UNSPECIFIED:
        }

        setMeasuredDimension(width, height);
    } else {
        super.onMeasure(recycler, state, widthSpec, heightSpec);
    }
}

private void measureScrapChild(RecyclerView.Recycler recycler, int position, int widthSpec,
                               int heightSpec, int[] measuredDimension) {

   View view = recycler.getViewForPosition(position);

   // For adding Item Decor Insets to view
   super.measureChildWithMargins(view, 0, 0);
    if (view != null) {
        RecyclerView.LayoutParams p = (RecyclerView.LayoutParams) view.getLayoutParams();
        int childWidthSpec = ViewGroup.getChildMeasureSpec(widthSpec,
                    getPaddingLeft() + getPaddingRight() + getDecoratedLeft(view) + getDecoratedRight(view), p.width);
            int childHeightSpec = ViewGroup.getChildMeasureSpec(heightSpec,
                    getPaddingTop() + getPaddingBottom() + getPaddingBottom() + getDecoratedBottom(view) , p.height);
            view.measure(childWidthSpec, childHeightSpec);

            // Get decorated measurements
            measuredDimension[0] = getDecoratedMeasuredWidth(view) + p.leftMargin + p.rightMargin;
            measuredDimension[1] = getDecoratedMeasuredHeight(view) + p.bottomMargin + p.topMargin;
            recycler.recycleView(view);
        }
    }
}

और अगर आप इसे GridLayoutManager के साथ उपयोग करना चाहते हैं, तो इसे GridLayoutManager से बदल कर बदल दें

for (int i = 0; i < getItemCount(); i++)

सेवा

for (int i = 0; i < getItemCount(); i = i + getSpanCount())

4
यह समाधान है कि सही ढंग से काम करता है, मैं इस थ्रेड के सभी दूसरों परीक्षण किया है और वे सभी मुद्दों था
wasyl

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

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

हम के लिए एक ही कैसे प्राप्त कर सकते gridlayoutmanagerहैं और staggeredgridlayoutmanagerमन में अवधि गिनती पर विचार?
अमृत ​​बिदरी

क्या यह MyLinearLayoutManager को चाइल्ड रिसाइकलर व्यू या पैरेंट के लिए लागू किया जाना चाहिए? अथवा दोनों?
कॉमनसिडेंसकोड

21

अद्यतन मार्च 2016

एंड्रॉइड सपोर्ट लाइब्रेरी द्वारा 23.2.1 समर्थन लाइब्रेरी संस्करण। तो सभी WRAP_CONTENT को सही तरीके से काम करना चाहिए।

कृपया फ़ाइल में लाइब्रेरी के संस्करण को अपडेट करें।

compile 'com.android.support:recyclerview-v7:23.2.1'

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

आप कॉल करने की आवश्यकता होगी setAutoMeasureEnabled (सही)

अद्यतन में विभिन्न माप-कल्पना विधियों से संबंधित फिक्स्ड बग

चेक https://developer.android.com/topic/libraries/support-library/features.html


14

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

public class WrappingRecyclerViewLayoutManager extends LinearLayoutManager {

public WrappingRecyclerViewLayoutManager(Context context)    {
    super(context, VERTICAL, false);
}

public WrappingRecyclerViewLayoutManager(Context context, int orientation, boolean reverseLayout)    {
    super(context, orientation, reverseLayout);
}

private int[] mMeasuredDimension = new int[2];

@Override
public void onMeasure(RecyclerView.Recycler recycler, RecyclerView.State state, int widthSpec, int heightSpec) {
    final int widthMode = View.MeasureSpec.getMode(widthSpec);
    final int heightMode = View.MeasureSpec.getMode(heightSpec);
    final int widthSize = View.MeasureSpec.getSize(widthSpec);
    final int heightSize = View.MeasureSpec.getSize(heightSpec);
    int width = 0;
    int height = 0;
    for (int i = 0; i < getItemCount(); i++) {
        measureScrapChild(recycler, i,
                View.MeasureSpec.makeMeasureSpec(i, View.MeasureSpec.UNSPECIFIED),
                View.MeasureSpec.makeMeasureSpec(i, View.MeasureSpec.UNSPECIFIED),
                mMeasuredDimension);
        if (getOrientation() == HORIZONTAL) {
            width = width + mMeasuredDimension[0];
            if (i == 0) {
                height = mMeasuredDimension[1];
            }
        } else {
            height = height + mMeasuredDimension[1];
            if (i == 0) {
                width = mMeasuredDimension[0];
            }
        }
    }
    switch (widthMode) {
        case View.MeasureSpec.EXACTLY:
            width = widthSize;
        case View.MeasureSpec.AT_MOST:
        case View.MeasureSpec.UNSPECIFIED:
    }

    switch (heightMode) {
        case View.MeasureSpec.EXACTLY:
            height = heightSize;
        case View.MeasureSpec.AT_MOST:
        case View.MeasureSpec.UNSPECIFIED:
    }

    setMeasuredDimension(width, height);
}

private void measureScrapChild(RecyclerView.Recycler recycler, int position, int widthSpec, int heightSpec, int[] measuredDimension) {
    View view = recycler.getViewForPosition(position);
    if (view != null) {
        RecyclerView.LayoutParams p = (RecyclerView.LayoutParams) view.getLayoutParams();
        int childWidthSpec = ViewGroup.getChildMeasureSpec(widthSpec, getPaddingLeft() + getPaddingRight(), p.width);
        int childHeightSpec = ViewGroup.getChildMeasureSpec(heightSpec, getPaddingTop() + getPaddingBottom(), p.height);
        view.measure(childWidthSpec, childHeightSpec);
        Rect outRect = new Rect();
        calculateItemDecorationsForChild(view, outRect);
        measuredDimension[0] = view.getMeasuredWidth() + p.leftMargin + p.rightMargin;
        measuredDimension[1] = view.getMeasuredHeight() + p.bottomMargin + p.topMargin + outRect.bottom + outRect.top;
        recycler.recycleView(view);
    }
}

}


1
अंत में, केवल एक चीज जो सही ढंग से काम करती है। अच्छा कार्य। धन्यवाद!
फाल्कन 3

3
मुझे java.lang.IndexOutOfBoundsException मिल रहा है: अमान्य आइटम स्थिति 0 (0)। आइटम गणना: 0 अपवाद।
RAHULRSANNIDHI

9

लेआउटमैनगर का विस्तार करने का एक विकल्प केवल दृश्य के आकार को मैन्युअल रूप से सेट किया जा सकता है।

प्रति पंक्ति ऊँचाई पर आइटमों की संख्या (यदि सभी मदों की ऊँचाई समान है और विभाजक को पंक्ति में शामिल किया गया है)

LinearLayout.LayoutParams params = (LinearLayout.LayoutParams) mListView.getLayoutParams();
params.height = mAdapter.getItemCount() * getResources().getDimensionPixelSize(R.dimen.row_height);
mListView.setLayoutParams(params);

अभी भी एक वर्कअराउंड है, लेकिन बुनियादी मामलों के लिए यह काम करता है।


6

यहाँ मुझे एक समाधान मिला है: https://code.google.com/p/android/issues/detail?id=74772

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

समाधान के रूप में LayoutManager का विस्तार करना है और इसकी ऑनमार्ट विधि को ओवरराइड करना है जैसा कि @yigit ने सुझाव दिया है।

लिंक के मरने की स्थिति में यह कोड है:

public static class MyLinearLayoutManager extends LinearLayoutManager {

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

    private int[] mMeasuredDimension = new int[2];

    @Override
    public void onMeasure(RecyclerView.Recycler recycler, RecyclerView.State state,
                          int widthSpec, int heightSpec) {
        final int widthMode = View.MeasureSpec.getMode(widthSpec);
        final int heightMode = View.MeasureSpec.getMode(heightSpec);
        final int widthSize = View.MeasureSpec.getSize(widthSpec);
        final int heightSize = View.MeasureSpec.getSize(heightSpec);

        measureScrapChild(recycler, 0,
                View.MeasureSpec.makeMeasureSpec(0, View.MeasureSpec.UNSPECIFIED),
                View.MeasureSpec.makeMeasureSpec(0, View.MeasureSpec.UNSPECIFIED),
                mMeasuredDimension);

        int width = mMeasuredDimension[0];
        int height = mMeasuredDimension[1];

        switch (widthMode) {
            case View.MeasureSpec.EXACTLY:
            case View.MeasureSpec.AT_MOST:
                width = widthSize;
                break;
            case View.MeasureSpec.UNSPECIFIED:
        }

        switch (heightMode) {
            case View.MeasureSpec.EXACTLY:
            case View.MeasureSpec.AT_MOST:
                height = heightSize;
                break;
            case View.MeasureSpec.UNSPECIFIED:
        }

        setMeasuredDimension(width, height);
    }

    private void measureScrapChild(RecyclerView.Recycler recycler, int position, int widthSpec,
                                   int heightSpec, int[] measuredDimension) {
        View view = recycler.getViewForPosition(position);
        if (view != null) {
            RecyclerView.LayoutParams p = (RecyclerView.LayoutParams) view.getLayoutParams();
            int childWidthSpec = ViewGroup.getChildMeasureSpec(widthSpec,
                    getPaddingLeft() + getPaddingRight(), p.width);
            int childHeightSpec = ViewGroup.getChildMeasureSpec(heightSpec,
                    getPaddingTop() + getPaddingBottom(), p.height);
            view.measure(childWidthSpec, childHeightSpec);
            measuredDimension[0] = view.getMeasuredWidth();
            measuredDimension[1] = view.getMeasuredHeight();
            recycler.recycleView(view);
        }
    }
}

बिंगो! क्षैतिज के साथ सही काम किया लेकिन ऊर्ध्वाधर के साथ नहीं
एच रावल

5

कुछ कीड़ों को छोड़कर @ सिनान-कोजक से उपयोग किया गया घोल। विशेष रूप से, हम उपयोग नहीं करना चाहिए View.MeasureSpec.UNSPECIFIEDके लिए दोनों जब बुला चौड़ाई और ऊंचाई measureScrapChildहै जो ठीक से बच्चे में लिपटे पाठ के लिए खाते में नहीं होगा। इसके बजाय, हम माता-पिता से चौड़ाई और ऊंचाई मोड से गुजरेंगे जो क्षैतिज और ऊर्ध्वाधर दोनों के लिए काम करने की अनुमति देगा।

public class MyLinearLayoutManager extends LinearLayoutManager {

public MyLinearLayoutManager(Context context, int orientation, boolean reverseLayout)    {
    super(context, orientation, reverseLayout);
}

private int[] mMeasuredDimension = new int[2];

@Override
public void onMeasure(RecyclerView.Recycler recycler, RecyclerView.State state,
                      int widthSpec, int heightSpec) {
    final int widthMode = View.MeasureSpec.getMode(widthSpec);
    final int heightMode = View.MeasureSpec.getMode(heightSpec);
    final int widthSize = View.MeasureSpec.getSize(widthSpec);
    final int heightSize = View.MeasureSpec.getSize(heightSpec);
    int width = 0;
    int height = 0;
    for (int i = 0; i < getItemCount(); i++) {    
        if (getOrientation() == HORIZONTAL) {
            measureScrapChild(recycler, i,
                View.MeasureSpec.makeMeasureSpec(0, View.MeasureSpec.UNSPECIFIED),
                View.MeasureSpec.makeMeasureSpec(heightSize, heightMode),
                mMeasuredDimension);

            width = width + mMeasuredDimension[0];
            if (i == 0) {
                height = mMeasuredDimension[1];
            }
        } else {
            measureScrapChild(recycler, i,
                View.MeasureSpec.makeMeasureSpec(widthSize, widthMode),
                View.MeasureSpec.makeMeasureSpec(0, View.MeasureSpec.UNSPECIFIED),
                mMeasuredDimension);

            height = height + mMeasuredDimension[1];
            if (i == 0) {
                width = mMeasuredDimension[0];
            }
        }
    }

    // If child view is more than screen size, there is no need to make it wrap content. We can use original onMeasure() so we can scroll view.
    if (height < heightSize && width < widthSize) {

        switch (widthMode) {
            case View.MeasureSpec.EXACTLY:
                width = widthSize;
            case View.MeasureSpec.AT_MOST:
            case View.MeasureSpec.UNSPECIFIED:
        }

        switch (heightMode) {
            case View.MeasureSpec.EXACTLY:
                height = heightSize;
            case View.MeasureSpec.AT_MOST:
            case View.MeasureSpec.UNSPECIFIED:
        }

        setMeasuredDimension(width, height);
    } else {
        super.onMeasure(recycler, state, widthSpec, heightSpec);
    }
}

private void measureScrapChild(RecyclerView.Recycler recycler, int position, int widthSpec,
                               int heightSpec, int[] measuredDimension) {

   View view = recycler.getViewForPosition(position);

   // For adding Item Decor Insets to view
   super.measureChildWithMargins(view, 0, 0);
    if (view != null) {
        RecyclerView.LayoutParams p = (RecyclerView.LayoutParams) view.getLayoutParams();
        int childWidthSpec = ViewGroup.getChildMeasureSpec(widthSpec,
                    getPaddingLeft() + getPaddingRight() + getDecoratedLeft(view) + getDecoratedRight(view), p.width);
            int childHeightSpec = ViewGroup.getChildMeasureSpec(heightSpec,
                    getPaddingTop() + getPaddingBottom() + getDecoratedTop(view) + getDecoratedBottom(view) , p.height);
            view.measure(childWidthSpec, childHeightSpec);

            // Get decorated measurements
            measuredDimension[0] = getDecoratedMeasuredWidth(view) + p.leftMargin + p.rightMargin;
            measuredDimension[1] = getDecoratedMeasuredHeight(view) + p.bottomMargin + p.topMargin;
            recycler.recycleView(view);
        }
    }
}

`


मैंने परीक्षण किया है और यह काम करता है, लेकिन केवल अगर एक RecyclerViewमें नेस्टेड है LinearLayout। साथ काम नहीं करता RelativeLayout
user2968401

3

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

public class MyLinearLayoutManager extends android.support.v7.widget.LinearLayoutManager {

private static boolean canMakeInsetsDirty = true;
private static Field insetsDirtyField = null;

private static final int CHILD_WIDTH = 0;
private static final int CHILD_HEIGHT = 1;
private static final int DEFAULT_CHILD_SIZE = 100;

private final int[] childDimensions = new int[2];
private final RecyclerView view;

private int childSize = DEFAULT_CHILD_SIZE;
private boolean hasChildSize;
private int overScrollMode = ViewCompat.OVER_SCROLL_ALWAYS;
private final Rect tmpRect = new Rect();

@SuppressWarnings("UnusedDeclaration")
public MyLinearLayoutManager(Context context) {
    super(context);
    this.view = null;
}

@SuppressWarnings("UnusedDeclaration")
public MyLinearLayoutManager(Context context, int orientation, boolean reverseLayout) {
    super(context, orientation, reverseLayout);
    this.view = null;
}

@SuppressWarnings("UnusedDeclaration")
public MyLinearLayoutManager(RecyclerView view) {
    super(view.getContext());
    this.view = view;
    this.overScrollMode = ViewCompat.getOverScrollMode(view);
}

@SuppressWarnings("UnusedDeclaration")
public MyLinearLayoutManager(RecyclerView view, int orientation, boolean reverseLayout) {
    super(view.getContext(), orientation, reverseLayout);
    this.view = view;
    this.overScrollMode = ViewCompat.getOverScrollMode(view);
}

public void setOverScrollMode(int overScrollMode) {
    if (overScrollMode < ViewCompat.OVER_SCROLL_ALWAYS || overScrollMode > ViewCompat.OVER_SCROLL_NEVER)
        throw new IllegalArgumentException("Unknown overscroll mode: " + overScrollMode);
    if (this.view == null) throw new IllegalStateException("view == null");
    this.overScrollMode = overScrollMode;
    ViewCompat.setOverScrollMode(view, overScrollMode);
}

public static int makeUnspecifiedSpec() {
    return View.MeasureSpec.makeMeasureSpec(0, View.MeasureSpec.UNSPECIFIED);
}

@Override
public void onMeasure(RecyclerView.Recycler recycler, RecyclerView.State state, int widthSpec, int heightSpec) {
    final int widthMode = View.MeasureSpec.getMode(widthSpec);
    final int heightMode = View.MeasureSpec.getMode(heightSpec);

    final int widthSize = View.MeasureSpec.getSize(widthSpec);
    final int heightSize = View.MeasureSpec.getSize(heightSpec);

    final boolean hasWidthSize = widthMode != View.MeasureSpec.UNSPECIFIED;
    final boolean hasHeightSize = heightMode != View.MeasureSpec.UNSPECIFIED;

    final boolean exactWidth = widthMode == View.MeasureSpec.EXACTLY;
    final boolean exactHeight = heightMode == View.MeasureSpec.EXACTLY;

    final int unspecified = makeUnspecifiedSpec();

    if (exactWidth && exactHeight) {
        // in case of exact calculations for both dimensions let's use default "onMeasure" implementation
        super.onMeasure(recycler, state, widthSpec, heightSpec);
        return;
    }

    final boolean vertical = getOrientation() == VERTICAL;

    initChildDimensions(widthSize, heightSize, vertical);

    int width = 0;
    int height = 0;

    // it's possible to get scrap views in recycler which are bound to old (invalid) adapter entities. This
    // happens because their invalidation happens after "onMeasure" method. As a workaround let's clear the
    // recycler now (it should not cause any performance issues while scrolling as "onMeasure" is never
    // called whiles scrolling)
    recycler.clear();

    final int stateItemCount = state.getItemCount();
    final int adapterItemCount = getItemCount();
    // adapter always contains actual data while state might contain old data (f.e. data before the animation is
    // done). As we want to measure the view with actual data we must use data from the adapter and not from  the
    // state
    for (int i = 0; i < adapterItemCount; i++) {
        if (vertical) {
            if (!hasChildSize) {
                if (i < stateItemCount) {
                    // we should not exceed state count, otherwise we'll get IndexOutOfBoundsException. For such items
                    // we will use previously calculated dimensions
                    measureChild(recycler, i, widthSize, unspecified, childDimensions);
                } else {
                    logMeasureWarning(i);
                }
            }
            height += childDimensions[CHILD_HEIGHT];
            if (i == 0) {
                width = childDimensions[CHILD_WIDTH];
            }
            if (hasHeightSize && height >= heightSize) {
                break;
            }
        } else {
            if (!hasChildSize) {
                if (i < stateItemCount) {
                    // we should not exceed state count, otherwise we'll get IndexOutOfBoundsException. For such items
                    // we will use previously calculated dimensions
                    measureChild(recycler, i, unspecified, heightSize, childDimensions);
                } else {
                    logMeasureWarning(i);
                }
            }
            width += childDimensions[CHILD_WIDTH];
            if (i == 0) {
                height = childDimensions[CHILD_HEIGHT];
            }
            if (hasWidthSize && width >= widthSize) {
                break;
            }
        }
    }

    if (exactWidth) {
        width = widthSize;
    } else {
        width += getPaddingLeft() + getPaddingRight();
        if (hasWidthSize) {
            width = Math.min(width, widthSize);
        }
    }

    if (exactHeight) {
        height = heightSize;
    } else {
        height += getPaddingTop() + getPaddingBottom();
        if (hasHeightSize) {
            height = Math.min(height, heightSize);
        }
    }

    setMeasuredDimension(width, height);

    if (view != null && overScrollMode == ViewCompat.OVER_SCROLL_IF_CONTENT_SCROLLS) {
        final boolean fit = (vertical && (!hasHeightSize || height < heightSize))
                || (!vertical && (!hasWidthSize || width < widthSize));

        ViewCompat.setOverScrollMode(view, fit ? ViewCompat.OVER_SCROLL_NEVER : ViewCompat.OVER_SCROLL_ALWAYS);
    }
}

private void logMeasureWarning(int child) {
    if (BuildConfig.DEBUG) {
        Log.w("MyLinearLayoutManager", "Can't measure child #" + child + ", previously used dimensions will be reused." +
                "To remove this message either use #setChildSize() method or don't run RecyclerView animations");
    }
}

private void initChildDimensions(int width, int height, boolean vertical) {
    if (childDimensions[CHILD_WIDTH] != 0 || childDimensions[CHILD_HEIGHT] != 0) {
        // already initialized, skipping
        return;
    }
    if (vertical) {
        childDimensions[CHILD_WIDTH] = width;
        childDimensions[CHILD_HEIGHT] = childSize;
    } else {
        childDimensions[CHILD_WIDTH] = childSize;
        childDimensions[CHILD_HEIGHT] = height;
    }
}

@Override
public void setOrientation(int orientation) {
    // might be called before the constructor of this class is called
    //noinspection ConstantConditions
    if (childDimensions != null) {
        if (getOrientation() != orientation) {
            childDimensions[CHILD_WIDTH] = 0;
            childDimensions[CHILD_HEIGHT] = 0;
        }
    }
    super.setOrientation(orientation);
}

public void clearChildSize() {
    hasChildSize = false;
    setChildSize(DEFAULT_CHILD_SIZE);
}

public void setChildSize(int childSize) {
    hasChildSize = true;
    if (this.childSize != childSize) {
        this.childSize = childSize;
        requestLayout();
    }
}

private void measureChild(RecyclerView.Recycler recycler, int position, int widthSize, int heightSize, int[] dimensions) {
    final View child;
    try {
        child = recycler.getViewForPosition(position);
    } catch (IndexOutOfBoundsException e) {
        if (BuildConfig.DEBUG) {
            Log.w("MyLinearLayoutManager", "MyLinearLayoutManager doesn't work well with animations. Consider switching them off", e);
        }
        return;
    }

    final RecyclerView.LayoutParams p = (RecyclerView.LayoutParams) child.getLayoutParams();

    final int hPadding = getPaddingLeft() + getPaddingRight();
    final int vPadding = getPaddingTop() + getPaddingBottom();

    final int hMargin = p.leftMargin + p.rightMargin;
    final int vMargin = p.topMargin + p.bottomMargin;

    // we must make insets dirty in order calculateItemDecorationsForChild to work
    makeInsetsDirty(p);
    // this method should be called before any getXxxDecorationXxx() methods
    calculateItemDecorationsForChild(child, tmpRect);

    final int hDecoration = getRightDecorationWidth(child) + getLeftDecorationWidth(child);
    final int vDecoration = getTopDecorationHeight(child) + getBottomDecorationHeight(child);

    final int childWidthSpec = getChildMeasureSpec(widthSize, hPadding + hMargin + hDecoration, p.width, canScrollHorizontally());
    final int childHeightSpec = getChildMeasureSpec(heightSize, vPadding + vMargin + vDecoration, p.height, canScrollVertically());

    child.measure(childWidthSpec, childHeightSpec);

    dimensions[CHILD_WIDTH] = getDecoratedMeasuredWidth(child) + p.leftMargin + p.rightMargin;
    dimensions[CHILD_HEIGHT] = getDecoratedMeasuredHeight(child) + p.bottomMargin + p.topMargin;

    // as view is recycled let's not keep old measured values
    makeInsetsDirty(p);
    recycler.recycleView(child);
}

private static void makeInsetsDirty(RecyclerView.LayoutParams p) {
    if (!canMakeInsetsDirty) {
        return;
    }
    try {
        if (insetsDirtyField == null) {
            insetsDirtyField = RecyclerView.LayoutParams.class.getDeclaredField("mInsetsDirty");
            insetsDirtyField.setAccessible(true);
        }
        insetsDirtyField.set(p, true);
    } catch (NoSuchFieldException e) {
        onMakeInsertDirtyFailed();
    } catch (IllegalAccessException e) {
        onMakeInsertDirtyFailed();
    }
}

private static void onMakeInsertDirtyFailed() {
    canMakeInsetsDirty = false;
    if (BuildConfig.DEBUG) {
        Log.w("MyLinearLayoutManager", "Can't make LayoutParams insets dirty, decorations measurements might be incorrect");
    }
}
}

3

Android समर्थन लाइब्रेरी अब WRAP_CONTENT संपत्ति को भी संभालती है। बस इसे अपने ग्रेडेल में आयात करें।

compile 'com.android.support:recyclerview-v7:23.2.0'

और हो गया!


2

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

इस समस्या को हल करने के लिए, मैंने समाधान को भंग कर दिया ताकि यह प्रदान किए गए आकार और गणना किए गए आकार के मिनट को चुन सके। निचे देखो:

package com.linkdev.gafi.adapters;

import android.content.Context;
import android.support.v7.widget.LinearLayoutManager;
import android.support.v7.widget.RecyclerView;
import android.view.View;
import android.view.ViewGroup;

import com.linkdev.gafi.R;

public class MyLinearLayoutManager extends LinearLayoutManager {

    public MyLinearLayoutManager(Context context, int orientation, boolean reverseLayout)    {
        super(context, orientation, reverseLayout);
        this.c = context;
    }


    private Context c;
    private int[] mMeasuredDimension = new int[2];


    @Override
    public void onMeasure(RecyclerView.Recycler recycler, RecyclerView.State state,
                          int widthSpec, int heightSpec) {
        final int widthMode = View.MeasureSpec.getMode(widthSpec);
        final int heightMode = View.MeasureSpec.getMode(heightSpec);
        final int widthSize = View.MeasureSpec.getSize(widthSpec);
        final int heightSize = View.MeasureSpec.getSize(heightSpec);



        int width = 0;
        int height = 0;
        for (int i = 0; i < getItemCount(); i++) {
            measureScrapChild(recycler, i,
                    View.MeasureSpec.makeMeasureSpec(i, View.MeasureSpec.UNSPECIFIED),
                    View.MeasureSpec.makeMeasureSpec(i, View.MeasureSpec.UNSPECIFIED),
                    mMeasuredDimension);

            if (getOrientation() == HORIZONTAL) {
                width = width + mMeasuredDimension[0];
                if (i == 0) {
                    height = mMeasuredDimension[1];
                }
            } else {
                height = height + mMeasuredDimension[1];
                if (i == 0) {
                    width = mMeasuredDimension[0];
                }
            }
        }


        switch (widthMode) {
            case View.MeasureSpec.EXACTLY:
                width = widthSize;
            case View.MeasureSpec.AT_MOST:
            case View.MeasureSpec.UNSPECIFIED:
        }

        switch (heightMode) {
            case View.MeasureSpec.EXACTLY:
                height = heightSize;
            case View.MeasureSpec.AT_MOST:
            case View.MeasureSpec.UNSPECIFIED:
        }

        int widthDesired = Math.min(widthSize,width);
        setMeasuredDimension(widthDesired, height);
    }

    private void measureScrapChild(RecyclerView.Recycler recycler, int position, int widthSpec,
                                   int heightSpec, int[] measuredDimension) {
        View view = recycler.getViewForPosition(position);
        if (view != null) {
            RecyclerView.LayoutParams p = (RecyclerView.LayoutParams) view.getLayoutParams();
            int childWidthSpec = ViewGroup.getChildMeasureSpec(widthSpec,
                    getPaddingLeft() + getPaddingRight(), p.width);
            int childHeightSpec = ViewGroup.getChildMeasureSpec(heightSpec,
                    getPaddingTop() + getPaddingBottom(), p.height);
            view.measure(childWidthSpec, childHeightSpec);
            measuredDimension[0] = view.getMeasuredWidth() + p.leftMargin + p.rightMargin;
            measuredDimension[1] = view.getMeasuredHeight() + p.bottomMargin + p.topMargin;
            recycler.recycleView(view);
        }
    }}

1

मैंने सभी समाधानों की कोशिश की है, वे बहुत उपयोगी हैं लेकिन यह केवल मेरे लिए ठीक काम करता है

public class  LinearLayoutManager extends android.support.v7.widget.LinearLayoutManager {

    public LinearLayoutManager(Context context, int orientation, boolean reverseLayout)    {
        super(context, orientation, reverseLayout);
    }

    private int[] mMeasuredDimension = new int[2];

    @Override
    public void onMeasure(RecyclerView.Recycler recycler, RecyclerView.State state,
                          int widthSpec, int heightSpec) {
        final int widthMode = View.MeasureSpec.getMode(widthSpec);
        final int heightMode = View.MeasureSpec.getMode(heightSpec);
        final int widthSize = View.MeasureSpec.getSize(widthSpec);
        final int heightSize = View.MeasureSpec.getSize(heightSpec);
        int width = 0;
        int height = 0;
        for (int i = 0; i < getItemCount(); i++) {


            if (getOrientation() == HORIZONTAL) {

                measureScrapChild(recycler, i,
                        View.MeasureSpec.makeMeasureSpec(i, View.MeasureSpec.UNSPECIFIED),
                        heightSpec,
                        mMeasuredDimension);

                width = width + mMeasuredDimension[0];
                if (i == 0) {
                    height = mMeasuredDimension[1];
                }
            } else {
                measureScrapChild(recycler, i,
                        widthSpec,
                        View.MeasureSpec.makeMeasureSpec(i, View.MeasureSpec.UNSPECIFIED),
                        mMeasuredDimension);
                height = height + mMeasuredDimension[1];
                if (i == 0) {
                    width = mMeasuredDimension[0];
                }
            }
        }

        if (height < heightSize || width < widthSize) {

            switch (widthMode) {
                case View.MeasureSpec.EXACTLY:
                    width = widthSize;
                case View.MeasureSpec.AT_MOST:
                case View.MeasureSpec.UNSPECIFIED:
            }

            switch (heightMode) {
                case View.MeasureSpec.EXACTLY:
                    height = heightSize;
                case View.MeasureSpec.AT_MOST:
                case View.MeasureSpec.UNSPECIFIED:
            }

            setMeasuredDimension(width, height);
        } else {
            super.onMeasure(recycler, state, widthSpec, heightSpec);
        }
    }

    private void measureScrapChild(RecyclerView.Recycler recycler, int position, int widthSpec,
                                   int heightSpec, int[] measuredDimension) {
        View view = recycler.getViewForPosition(position);
        recycler.bindViewToPosition(view, position);
        if (view != null) {
            RecyclerView.LayoutParams p = (RecyclerView.LayoutParams) view.getLayoutParams();
            int childWidthSpec = ViewGroup.getChildMeasureSpec(widthSpec,
                    getPaddingLeft() + getPaddingRight(), p.width);
            int childHeightSpec = ViewGroup.getChildMeasureSpec(heightSpec,
                    getPaddingTop() + getPaddingBottom(), p.height);
            view.measure(childWidthSpec, childHeightSpec);
            measuredDimension[0] = view.getMeasuredWidth() + p.leftMargin + p.rightMargin;
            measuredDimension[1] = view.getMeasuredHeight() + p.bottomMargin + p.topMargin;
            recycler.recycleView(view);
        }
    }
}

0

बस ग्रिड लेआउट के साथ RecyclerView का उपयोग कर सामग्री लपेटो

चित्र: ग्रिड व्यू लेआउट के रूप में रिसाइकलर

बस इस तरह GridLayoutManager का उपयोग करें:

RecyclerView.LayoutManager mRecyclerGrid=new GridLayoutManager(this,3,LinearLayoutManager.VERTICAL,false);
mRecyclerView.setLayoutManager(mRecyclerGrid);

आप यह निर्धारित कर सकते हैं कि एक पंक्ति में कितने आइटम दिखाई देने चाहिए (3 बदलें)।

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.