Android 5.0 - RecyclerView में शीर्ष लेख / पाद लेख जोड़ें


122

मैंने एक पल बिताने के लिए एक हेडर को जोड़ने का एक तरीका जानने की कोशिश की RecyclerView, असफल।

यह वही है जो मुझे अब तक मिला है:

@Override
protected void onCreate(Bundle savedInstanceState) {
    ...

    layouManager = new LinearLayoutManager(getActivity());
    recyclerView.setLayoutManager(layouManager);

    LayoutInflater inflater = (LayoutInflater) getActivity().getSystemService(Context.LAYOUT_INFLATER_SERVICE);
    headerPlaceHolder = inflater.inflate(R.layout.view_header_holder_medium, null, false);
    layouManager.addView(headerPlaceHolder, 0);

   ...
}

LayoutManagerवस्तु के स्वभाव से निपटने प्रतीत हो रहा है RecyclerViewआइटम नहीं है। मैं किसी भी नहीं मिल सका के रूप में addHeaderView(View view)विधि, मैं के साथ जाने का फैसला किया LayoutManagerहै addView(View view, int position)विधि और मेरे हैडर दृश्य जोड़ने के लिए पहले की स्थिति एक हेडर के रूप में कार्य करने के लिए।

यह वह जगह है जहां चीजें बदसूरत हो जाती हैं:

java.lang.NullPointerException: Attempt to read from field 'android.support.v7.widget.RecyclerView$ViewHolder android.support.v7.widget.RecyclerView$LayoutParams.mViewHolder' on a null object reference
    at android.support.v7.widget.RecyclerView.getChildViewHolderInt(RecyclerView.java:2497)
    at android.support.v7.widget.RecyclerView$LayoutManager.addViewInt(RecyclerView.java:4807)
    at android.support.v7.widget.RecyclerView$LayoutManager.addView(RecyclerView.java:4803)
    at com.mathieumaree.showz.fragments.CategoryFragment.setRecyclerView(CategoryFragment.java:231)
    at com.mathieumaree.showz.fragments.CategoryFragment.access$200(CategoryFragment.java:47)
    at com.mathieumaree.showz.fragments.CategoryFragment$2.success(CategoryFragment.java:201)
    at com.mathieumaree.showz.fragments.CategoryFragment$2.success(CategoryFragment.java:196)
    at retrofit.CallbackRunnable$1.run(CallbackRunnable.java:41)
    at android.os.Handler.handleCallback(Handler.java:739)
    at android.os.Handler.dispatchMessage(Handler.java:95)
    at android.os.Looper.loop(Looper.java:135)
    at android.app.ActivityThread.main(ActivityThread.java:5221)
    at java.lang.reflect.Method.invoke(Native Method)
    at java.lang.reflect.Method.invoke(Method.java:372)
    at com.android.internal.os.ZygoteInit$MethodAndArgsCaller.run(ZygoteInit.java:899)
    at com.android.internal.os.ZygoteInit.main(ZygoteInit.java:694)

गतिविधि निर्माण के विभिन्न क्षणों में NullPointerExceptionsकॉल करने के लिए कई प्रयास करने के बाद addView(View view)(यह भी देखने की कोशिश की कि एक बार सब कुछ सेट हो जाए, यहां तक ​​कि एडॉप्टर का डेटा भी), मुझे एहसास हुआ कि मुझे इसका कोई पता नहीं है अगर यह करने का सही तरीका है (और यह) लगती नहीं है)।

पुनश्च: इसके अलावा, एक समाधान जो वास्तव में सराहना GridLayoutManagerकी LinearLayoutManagerजाएगी के अलावा संभाल सकता है !


एक इस पर नज़र रखना stackoverflow.com/a/26573338/2127203
EC84B4

समस्या एडॉप्टर कोड में है। इसका मतलब है, किसी तरह आप onCreateViewHolder फ़ंक्शन में अशक्त व्यूअर को लौटा रहे हैं।
नव

जवाबों:


120

मुझे अपने लिए एक पाद जोड़ना था RecyclerViewऔर यहाँ मैं अपना कोड स्निपेट साझा कर रहा हूँ क्योंकि मुझे लगा कि यह उपयोगी हो सकता है। कृपया समग्र प्रवाह की बेहतर समझ के लिए कोड के अंदर टिप्पणियों की जाँच करें।

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

import java.util.ArrayList;

public class RecyclerViewWithFooterAdapter extends RecyclerView.Adapter<RecyclerView.ViewHolder> {

    private static final int FOOTER_VIEW = 1;
    private ArrayList<String> data; // Take any list that matches your requirement.
    private Context context;

    // Define a constructor
    public RecyclerViewWithFooterAdapter(Context context, ArrayList<String> data) {
        this.context = context;
        this.data = data;
    }

    // Define a ViewHolder for Footer view
    public class FooterViewHolder extends ViewHolder {
        public FooterViewHolder(View itemView) {
            super(itemView);
            itemView.setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View v) {
                    // Do whatever you want on clicking the item
                }
            });
        }
    }

    // Now define the ViewHolder for Normal list item
    public class NormalViewHolder extends ViewHolder {
        public NormalViewHolder(View itemView) {
            super(itemView);

            itemView.setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View v) {
                    // Do whatever you want on clicking the normal items
                }
            });
        }
    }

    // And now in onCreateViewHolder you have to pass the correct view
    // while populating the list item.

    @Override
    public RecyclerView.ViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {

        View v;

        if (viewType == FOOTER_VIEW) {
            v = LayoutInflater.from(context).inflate(R.layout.list_item_footer, parent, false);
            FooterViewHolder vh = new FooterViewHolder(v);
            return vh;
        }

        v = LayoutInflater.from(context).inflate(R.layout.list_item_normal, parent, false);

        NormalViewHolder vh = new NormalViewHolder(v);

        return vh;
    }

    // Now bind the ViewHolder in onBindViewHolder
    @Override
    public void onBindViewHolder(RecyclerView.ViewHolder holder, int position) {

        try {
            if (holder instanceof NormalViewHolder) {
                NormalViewHolder vh = (NormalViewHolder) holder;

                vh.bindView(position);
            } else if (holder instanceof FooterViewHolder) {
                FooterViewHolder vh = (FooterViewHolder) holder;
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    // Now the critical part. You have return the exact item count of your list
    // I've only one footer. So I returned data.size() + 1
    // If you've multiple headers and footers, you've to return total count
    // like, headers.size() + data.size() + footers.size()

    @Override
    public int getItemCount() {
        if (data == null) {
            return 0;
        }

        if (data.size() == 0) {
            //Return 1 here to show nothing
            return 1;
        }

        // Add extra view to show the footer view
        return data.size() + 1;
    }

    // Now define getItemViewType of your own.

    @Override
    public int getItemViewType(int position) {
        if (position == data.size()) {
            // This is where we'll add footer.
            return FOOTER_VIEW;
        }

        return super.getItemViewType(position);
    }

    // So you're done with adding a footer and its action on onClick.
    // Now set the default ViewHolder for NormalViewHolder

    public class ViewHolder extends RecyclerView.ViewHolder {
        // Define elements of a row here
        public ViewHolder(View itemView) {
            super(itemView);
            // Find view by ID and initialize here
        }

        public void bindView(int position) {
            // bindView() method to implement actions
        }
    }
}

उपरोक्त कोड स्निपेट इसमें पाद जोड़ता है RecyclerView। आप इस GitHub रिपॉजिटरी को हेडर और फूटर दोनों को जोड़ने के कार्यान्वयन की जांच कर सकते हैं ।


2
अच्छा काम करता है। इसे सही उत्तर के रूप में चिह्नित किया जाना चाहिए।
नागा मल्लेश मददली

1
यह वास्तव में वही है जो मैंने किया है। लेकिन क्या होगा अगर मैं अपने RecyclerView कंपित सूची को अनुकूलित करना चाहता हूं? पहला तत्व (हेडर) भी कंपित होगा। :(
नियॉन वारगे

यह एक ट्यूटोरियल है कि आप अपने RecyclerViewगतिशील तरीके से कैसे आबाद कर सकते हैं । आप अपने प्रत्येक तत्व पर नियंत्रण रख सकते हैं RecyclerView। कृपया किसी कार्यशील प्रोजेक्ट के लिए कोड अनुभाग देखें। आशा है कि यह मदद कर सकता है। github.com/comeondude/dynamic-recyclerview/wiki
Reaz Murshed

2
int getItemViewType (int position)- दृश्य रीसाइक्लिंग के प्रयोजनों के लिए स्थिति में आइटम का प्रकार देखें। इस पद्धति का डिफ़ॉल्ट कार्यान्वयन 0 पर लौटता है, जिससे एडॉप्टर के लिए एकल दृश्य प्रकार की धारणा बन जाती है। ListViewएडेप्टर के विपरीत , प्रकारों को सन्निहित नहीं होना चाहिए। आइटम दृश्य प्रकारों की विशिष्ट पहचान के लिए आईडी संसाधनों का उपयोग करने पर विचार करें। - प्रोफेशन से। developer.android.com/reference/android/support/v7/widget/…
Reaz Murshed

3
कुछ लोगों के लिए इतना मैनुअल काम हमेशा करना चाहते हैं। मुझे विश्वास नहीं हो रहा है ...
जॉनीटेक्स

28

बहुत सरल है हल करने के लिए !!

मुझे एडेप्टर के अंदर तर्क को एक अलग दृश्य प्रकार के रूप में पसंद नहीं है क्योंकि दृश्य को वापस करने से पहले हर बार यह दृश्य प्रकार की जांच करता है। नीचे समाधान अतिरिक्त जांच से बचा जाता है।

बस Android.support.v4.widget.NestedScrollView के अंदर LinearLayout (ऊर्ध्वाधर) शीर्ष लेख दृश्य + recyclerview + पाद दृश्य जोड़ें

इसकी जांच करें:

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

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

       <View
            android:id="@+id/header"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"/>

        <android.support.v7.widget.RecyclerView
            android:id="@+id/list"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            app:layoutManager="LinearLayoutManager"/>

        <View
            android:id="@+id/footer"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"/>
    </LinearLayout>
</android.support.v4.widget.NestedScrollView>

चिकनी स्क्रॉलिंग के लिए कोड की इस पंक्ति को जोड़ें

RecyclerView v = (RecyclerView) findViewById(...);
v.setNestedScrollingEnabled(false);

यह सब आर.वी. प्रदर्शन खो देंगे और आर.वी. की परवाह किए बिना सभी दृश्य धारकों बाहर रखना करने की कोशिश करेंगे layout_heightआर.वी. की

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


1
मेरे लिए काफी सरल काम किया
हितेश साहू

1
हेडर और फुटर को एक सूची के भीतर दोहराने की ज़रूरत नहीं होने पर पुनरावर्ती दृश्य में हेडर और फ़ूटर को जोड़ने के बारे में जाने का यह एक बहुत ही सरल तरीका है।
user1841702

34
यह उन सभी लाभों को खोने का एक बहुत ही सरल तरीका है जो RecyclerViewलाता है - आप वास्तविक पुनर्चक्रण खो देते हैं और जो अनुकूलन लाता है।
मार्सिन कोज़ीस्की

1
मैंने इस कोड की कोशिश की, स्क्रॉल करना ठीक से काम नहीं कर रहा है ... यह बहुत धीमी गति से स्क्रॉल हो गया .. plz सुझाव है कि अगर इसके लिए कुछ कर सकता है
निभा जैन

2
नेस्टेड स्क्रोलव्यू का उपयोग करने से सभी दृश्य को कैश करने के लिए पुनरावर्तन होगा और अगर पुनर्नवीनीकरण दृश्य का आकार अधिक स्क्रॉल होता है और लोडिंग समय बढ़ जाएगा। मेरा सुझाव है कि इस कोड का उपयोग न करें
तुषार साहा

25

लॉलीपॉप पर मुझे एक ही समस्या थी और Recyclerviewएडाप्टर को लपेटने के लिए दो दृष्टिकोण बनाए । एक का उपयोग करना बहुत आसान है, लेकिन मुझे यकीन नहीं है कि यह एक बदलते डेटासेट के साथ कैसे व्यवहार करेगा। क्योंकि यह आपके एडॉप्टर को लपेटता है और आपको अपने आप को कॉल करने के तरीकों को सुनिश्चित करने की आवश्यकता होती हैnotifyDataSetChanged सही एडेप्टर-ऑब्जेक्ट होती है।

दूसरे को ऐसी समस्याएँ नहीं होनी चाहिए। बस अपने नियमित एडाप्टर को कक्षा का विस्तार करने दें, अमूर्त विधियों को लागू करें और आपको तैयार होना चाहिए। और यहाँ वे हैं:

gists

HeaderRecyclerViewAdapterV1

import android.support.v7.widget.RecyclerView;
import android.view.ViewGroup;

/**
 * Created by sebnapi on 08.11.14.
 * <p/>
 * This is a Plug-and-Play Approach for adding a Header or Footer to
 * a RecyclerView backed list
 * <p/>
 * Just wrap your regular adapter like this
 * <p/>
 * new HeaderRecyclerViewAdapterV1(new RegularAdapter())
 * <p/>
 * Let RegularAdapter implement HeaderRecyclerView, FooterRecyclerView or both
 * and you are ready to go.
 * <p/>
 * I'm absolutely not sure how this will behave with changes in the dataset.
 * You can always wrap a fresh adapter and make sure to not change the old one or
 * use my other approach.
 * <p/>
 * With the other approach you need to let your Adapter extend HeaderRecyclerViewAdapterV2
 * (and therefore change potentially more code) but possible omit these shortcomings.
 * <p/>
 * TOTALLY UNTESTED - USE WITH CARE - HAVE FUN :)
 */
public class HeaderRecyclerViewAdapterV1 extends RecyclerView.Adapter {
    private static final int TYPE_HEADER = Integer.MIN_VALUE;
    private static final int TYPE_FOOTER = Integer.MIN_VALUE + 1;
    private static final int TYPE_ADAPTEE_OFFSET = 2;

    private final RecyclerView.Adapter mAdaptee;


    public HeaderRecyclerViewAdapterV1(RecyclerView.Adapter adaptee) {
        mAdaptee = adaptee;
    }

    public RecyclerView.Adapter getAdaptee() {
        return mAdaptee;
    }

    @Override
    public RecyclerView.ViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
        if (viewType == TYPE_HEADER && mAdaptee instanceof HeaderRecyclerView) {
            return ((HeaderRecyclerView) mAdaptee).onCreateHeaderViewHolder(parent, viewType);
        } else if (viewType == TYPE_FOOTER && mAdaptee instanceof FooterRecyclerView) {
            return ((FooterRecyclerView) mAdaptee).onCreateFooterViewHolder(parent, viewType);
        }
        return mAdaptee.onCreateViewHolder(parent, viewType - TYPE_ADAPTEE_OFFSET);
    }

    @Override
    public void onBindViewHolder(RecyclerView.ViewHolder holder, int position) {
        if (position == 0 && holder.getItemViewType() == TYPE_HEADER && useHeader()) {
            ((HeaderRecyclerView) mAdaptee).onBindHeaderView(holder, position);
        } else if (position == mAdaptee.getItemCount() && holder.getItemViewType() == TYPE_FOOTER && useFooter()) {
            ((FooterRecyclerView) mAdaptee).onBindFooterView(holder, position);
        } else {
            mAdaptee.onBindViewHolder(holder, position - (useHeader() ? 1 : 0));
        }
    }

    @Override
    public int getItemCount() {
        int itemCount = mAdaptee.getItemCount();
        if (useHeader()) {
            itemCount += 1;
        }
        if (useFooter()) {
            itemCount += 1;
        }
        return itemCount;
    }

    private boolean useHeader() {
        if (mAdaptee instanceof HeaderRecyclerView) {
            return true;
        }
        return false;
    }

    private boolean useFooter() {
        if (mAdaptee instanceof FooterRecyclerView) {
            return true;
        }
        return false;
    }

    @Override
    public int getItemViewType(int position) {
        if (position == 0 && useHeader()) {
            return TYPE_HEADER;
        }
        if (position == mAdaptee.getItemCount() && useFooter()) {
            return TYPE_FOOTER;
        }
        if (mAdaptee.getItemCount() >= Integer.MAX_VALUE - TYPE_ADAPTEE_OFFSET) {
            new IllegalStateException("HeaderRecyclerViewAdapter offsets your BasicItemType by " + TYPE_ADAPTEE_OFFSET + ".");
        }
        return mAdaptee.getItemViewType(position) + TYPE_ADAPTEE_OFFSET;
    }


    public static interface HeaderRecyclerView {
        public RecyclerView.ViewHolder onCreateHeaderViewHolder(ViewGroup parent, int viewType);

        public void onBindHeaderView(RecyclerView.ViewHolder holder, int position);
    }

    public static interface FooterRecyclerView {
        public RecyclerView.ViewHolder onCreateFooterViewHolder(ViewGroup parent, int viewType);

        public void onBindFooterView(RecyclerView.ViewHolder holder, int position);
    }

}

HeaderRecyclerViewAdapterV2

import android.support.v7.widget.RecyclerView;
import android.view.ViewGroup;

/**
 * Created by sebnapi on 08.11.14.
 * <p/>
 * If you extend this Adapter you are able to add a Header, a Footer or both
 * by a similar ViewHolder pattern as in RecyclerView.
 * <p/>
 * If you want to omit changes to your class hierarchy you can try the Plug-and-Play
 * approach HeaderRecyclerViewAdapterV1.
 * <p/>
 * Don't override (Be careful while overriding)
 * - onCreateViewHolder
 * - onBindViewHolder
 * - getItemCount
 * - getItemViewType
 * <p/>
 * You need to override the abstract methods introduced by this class. This class
 * is not using generics as RecyclerView.Adapter make yourself sure to cast right.
 * <p/>
 * TOTALLY UNTESTED - USE WITH CARE - HAVE FUN :)
 */
public abstract class HeaderRecyclerViewAdapterV2 extends RecyclerView.Adapter {
    private static final int TYPE_HEADER = Integer.MIN_VALUE;
    private static final int TYPE_FOOTER = Integer.MIN_VALUE + 1;
    private static final int TYPE_ADAPTEE_OFFSET = 2;

    @Override
    public RecyclerView.ViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
        if (viewType == TYPE_HEADER) {
            return onCreateHeaderViewHolder(parent, viewType);
        } else if (viewType == TYPE_FOOTER) {
            return onCreateFooterViewHolder(parent, viewType);
        }
        return onCreateBasicItemViewHolder(parent, viewType - TYPE_ADAPTEE_OFFSET);
    }

    @Override
    public void onBindViewHolder(RecyclerView.ViewHolder holder, int position) {
        if (position == 0 && holder.getItemViewType() == TYPE_HEADER) {
            onBindHeaderView(holder, position);
        } else if (position == getBasicItemCount() && holder.getItemViewType() == TYPE_FOOTER) {
            onBindFooterView(holder, position);
        } else {
            onBindBasicItemView(holder, position - (useHeader() ? 1 : 0));
        }
    }

    @Override
    public int getItemCount() {
        int itemCount = getBasicItemCount();
        if (useHeader()) {
            itemCount += 1;
        }
        if (useFooter()) {
            itemCount += 1;
        }
        return itemCount;
    }

    @Override
    public int getItemViewType(int position) {
        if (position == 0 && useHeader()) {
            return TYPE_HEADER;
        }
        if (position == getBasicItemCount() && useFooter()) {
            return TYPE_FOOTER;
        }
        if (getBasicItemType(position) >= Integer.MAX_VALUE - TYPE_ADAPTEE_OFFSET) {
            new IllegalStateException("HeaderRecyclerViewAdapter offsets your BasicItemType by " + TYPE_ADAPTEE_OFFSET + ".");
        }
        return getBasicItemType(position) + TYPE_ADAPTEE_OFFSET;
    }

    public abstract boolean useHeader();

    public abstract RecyclerView.ViewHolder onCreateHeaderViewHolder(ViewGroup parent, int viewType);

    public abstract void onBindHeaderView(RecyclerView.ViewHolder holder, int position);

    public abstract boolean useFooter();

    public abstract RecyclerView.ViewHolder onCreateFooterViewHolder(ViewGroup parent, int viewType);

    public abstract void onBindFooterView(RecyclerView.ViewHolder holder, int position);

    public abstract RecyclerView.ViewHolder onCreateBasicItemViewHolder(ViewGroup parent, int viewType);

    public abstract void onBindBasicItemView(RecyclerView.ViewHolder holder, int position);

    public abstract int getBasicItemCount();

    /**
     * make sure you don't use [Integer.MAX_VALUE-1, Integer.MAX_VALUE] as BasicItemViewType
     *
     * @param position
     * @return
     */
    public abstract int getBasicItemType(int position);

}

प्रतिक्रिया और कांटे की सराहना की। मैं HeaderRecyclerViewAdapterV2अपने स्वयं के द्वारा उपयोग करूंगा और भविष्य में परिवर्तनों को विकसित और परीक्षण करूंगा।

EDIT : @OvidiuLatcu हां मुझे कुछ समस्याएं थीं। वास्तव में मैंने हेडर को स्पष्ट रूप से ऑफसेट करना बंद कर दिया position - (useHeader() ? 1 : 0)और इसके बदले एक सार्वजनिक विधि बनाई int offsetPosition(int position)। क्योंकि यदि आप OnItemTouchListenerRecyclerview पर सेट करते हैं , तो आप टच को इंटरसेप्ट कर सकते हैं, एक्स को प्राप्त कर सकते हैं, टच के y निर्देशांक प्राप्त कर सकते हैं, तदनुसार चाइल्ड व्यू देख सकते हैं और फिर कॉल recyclerView.getChildPosition(...)कर सकते हैं और आपको एडेप्टर में हमेशा नॉन-ऑफसेट स्थिति मिलेगी! यह RecyclerView कोड में एक छोटी सी कमी है, मैं इसे दूर करने के लिए एक आसान तरीका नहीं देखता। यही कारण है कि अब मुझे अपने स्वयं के कोड की आवश्यकता होने पर स्थिति स्पष्ट हो जाती है ।


अच्छा लग रहा है ! इसके साथ कोई परेशानी हो रही है? या हम सुरक्षित रूप से इसका उपयोग कर सकते हैं? : D
Ovidiu Latcu

1
@OvidiuLatcu पोस्ट देखें
seb

इन कार्यान्वयनों में, ऐसा लगता है कि आपने हेडर और फ़ुटर की संख्या को केवल 1 माना है?
ऋषभमंजन

@seb संस्करण 2 आकर्षण की तरह काम करता है !! केवल एक चीज जो मुझे संशोधित करने की आवश्यकता है, वह दोनों onBindViewHolder और getItemViewType विधियों पर पाद प्राप्त करने के लिए शर्त है। मुद्दा यह है कि अगर आप स्थिति == getBasicItemCount () का उपयोग करके स्थिति प्राप्त करते हैं, तो यह वास्तविक अंतिम स्थिति के लिए सही नहीं होगा, लेकिन अंतिम स्थिति - 1. यह वहाँ (नीचे नहीं) FooterView रखने समाप्त हो गया। हमने इसे स्थिति को स्थिति में बदलने के लिए तय किया == getBasicItemCount () + 1 और इसने बहुत अच्छा काम किया!
mmark

@seb संस्करण 2 इतना बढ़िया काम करता है। बहुत बहुत धन्यवाद। मैं इसका उपयोग कर रहा हूं। एक छोटी सी बात जो मेरा सुझाव है, वह ओवरराइड फ़ंक्शन के लिए 'अंतिम' कीवर्ड जोड़ना है।
रयानशो

10

मैंने यह कोशिश नहीं की है, लेकिन मैं आपके एडेप्टर में getItemCount द्वारा लौटाए गए पूर्णांक के लिए 1 (या 2, यदि आप हेडर और फुटर दोनों चाहते हैं) जोड़ सकते हैं। आप तब getItemViewTypeअपने एडेप्टर में ओवरराइड कर सकते हैं जब एक अलग पूर्णांक वापस करने के लिए i==0: https://developer.android.com/reference/android/support/v7/widget/RecyclerView.Adcape.html#getItemViewType(int)

createViewHolderतब आपके द्वारा लौटाए गए पूर्णांक को पास कर दिया जाता है getItemViewType, जिससे आप हेडर दृश्य के लिए व्यू होल्डर को अलग से बना या कॉन्फ़िगर कर सकते हैं: https://developer.android.com/reference/android/support/v7/widget/RecyclerView.Adcape.html# createViewHolder (android.view.ViewGroup , int)

पास किए गए पूर्णांक स्थिति से एक को घटाना मत भूलना bindViewHolder


मुझे नहीं लगता कि यह recyclerview का काम है। Recyclerviews का काम केवल विचारों को रीसायकल करना है। हेडर या पाद कार्यान्वयन के साथ एक लेआउटमैन लिखना एक रास्ता है।
IZI_Shadow_IZI

धन्यवाद @IanNewson आपके उत्तर के लिए। सबसे पहले, यह समाधान काम कर रहा है, यहां तक ​​कि केवल getItemViewType(int position) { return position == 0 ? 0 : 1; }( RecyclerViewएक getViewTypeCount()विधि नहीं है ) का उपयोग करते हुए । दूसरी ओर, मैं @IZI_Shadow_IZI से सहमत हूं, मुझे वास्तव में लग रहा है कि LayoutManager को इस तरह की चीजों को संभालने वाला होना चाहिए। कोई अन्य विचार?
मैथ्यूमैरी

@VieuMa शायद आप दोनों सही हैं, लेकिन मुझे नहीं पता कि वर्तमान में यह कैसे करना है और मुझे पूरा यकीन है कि मेरा समाधान काम करेगा। एक उप-अपनाने वाला समाधान बिना समाधान के बेहतर है, जो कि आपके पास पहले था।
इयान न्यूजन

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

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

9

आप इस GitHub लाइब्रेरी को अपने RecyclerView में Header और / या Footer को सरलतम तरीके से जोड़ने की अनुमति दे सकते हैं।

आपको अपनी परियोजना में HFRecyclerView पुस्तकालय को जोड़ने की आवश्यकता है या आप इसे ग्रैडल से भी पकड़ सकते हैं:

compile 'com.mikhaellopez:hfrecyclerview:1.0.0'

यह छवि का एक परिणाम है:

पूर्वावलोकन

संपादित करें:

यदि आप इस लाइब्रेरी के साथ ऊपर और / या नीचे एक मार्जिन जोड़ना चाहते हैं: SimpleItemDecoration :

int offsetPx = 10;
recyclerView.addItemDecoration(new StartOffsetItemDecoration(offsetPx));
recyclerView.addItemDecoration(new EndOffsetItemDecoration(offsetPx));

यह लाइब्रेरी LinearLayoutManager में हेडर पर ठीक से दृश्य जोड़ती है, लेकिन मैं GridLayoutManager में हेडर के रूप में दृश्य सेट करना चाहता हूं, जो स्क्रीन की पूरी चौड़ाई लेता है। क्या यह इस पुस्तकालय के साथ संभव है।
वेद

नहीं, यह लाइब्रेरी आपको adapting (RecyclerView.Adapter) पर एक पुनर्नवीनीकरण दृश्य के पहले और अंतिम तत्व को बदलने की अनुमति देती है। आप इस एडेप्टर को समस्याओं के बिना एक ग्रिड व्यू में उपयोग कर सकते हैं। इसलिए मुझे लगता है कि यह पुस्तकालय आपको वही करने की अनुमति देता है जो आप चाहते हैं।
लोपेजमाइकिल

6

मैंने अपना एडॉप्टर किसी अन्य एडेप्टर को लपेटने और हेडर और फ़ूटर व्यूज़ को जोड़ने के तरीके प्रदान करने के लिए लागू किया।

यहाँ एक जिस्ट बनाया गया: जिस्ट HeaderViewRecyclerAdapter.java

मुख्य विशेषता मैं चाहता था एक ListView लिए एक समान अंतरफलक था, इसलिए मैं अपने टुकड़ा में विचारों बढ़ और उन्हें जोड़ने के लिए सक्षम होना चाहता था RecyclerViewमें onCreateView। यह एक HeaderViewRecyclerAdapterगुजर एडेप्टर को लिपटे हुए बनाने के लिए, और आपके फुलाए हुए विचारों को कॉल करने addHeaderViewऔर addFooterViewपारित करने के द्वारा किया जाता है । फिर HeaderViewRecyclerAdapterउदाहरण के रूप में उदाहरण पर सेट करेंRecyclerView

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


3

मेरा "इसे सरल बेवकूफ बनाए रखें" रास्ता ... यह कुछ संसाधनों को बर्बाद करता है, मुझे पता है, लेकिन मुझे परवाह नहीं है क्योंकि मेरा कोड सरल है ... 1) दृश्यता के साथ पाद लेख जोड़ें आपके आइटम_ऑलआउट

  <LinearLayout
        android:id="@+id/footer"
        android:layout_width="match_parent"
        android:layout_height="80dp"
        android:orientation="vertical"
        android:visibility="gone">
    </LinearLayout>

2) फिर अंतिम आइटम पर दिखाई दे रहा है

public void onBindViewHolder(ChannelAdapter.MyViewHolder holder, int position) {
        boolean last = position==data.size()-1;
        //....
        holder.footer.setVisibility(View.GONE);
        if (last && showFooter){
            holder.footer.setVisibility(View.VISIBLE);
        }
    }

हेडर के लिए विपरीत करें


1

@ एसईबी के समाधान के आधार पर, मैंने RecyclerView.Adcape का एक उपवर्ग बनाया, जो हेडर और फ़ुटर्स की एक मनमानी संख्या का समर्थन करता है।

https://gist.github.com/mheras/0908873267def75dc746

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

मैं अभी भी इसका परीक्षण कर रहा हूं, लेकिन आप चाहें तो इसे आजमा सकते हैं। अगर आपको इसके साथ कोई समस्या मिलती है तो कृपया मुझे बताएं।


1

आप इस समस्या को हल करने के लिए viewtype का उपयोग कर सकते हैं, यहां मेरा डेमो है: https://github.com/yefengfreedom/RecyclerViewWithHeaderFooterLoadingEmptyViewErrorView

  1. आप कुछ पुनर्नवीनीकरण दृश्य प्रदर्शन मोड को परिभाषित कर सकते हैं:

    सार्वजनिक स्थिर अंतिम int MODE_DATA = 0, MODE_LOADING = 1, MODE_ERROR = 2, MODE_EMPTY = 3, MODE_HEADER_VIEW = 4, MODE_FOOTO_VIEW = 5;

2. getItemViewType mothod को हटा दें

 @Override
public int getItemViewType(int position) {
    if (mMode == RecyclerViewMode.MODE_LOADING) {
        return RecyclerViewMode.MODE_LOADING;
    }
    if (mMode == RecyclerViewMode.MODE_ERROR) {
        return RecyclerViewMode.MODE_ERROR;
    }
    if (mMode == RecyclerViewMode.MODE_EMPTY) {
        return RecyclerViewMode.MODE_EMPTY;
    }
    //check what type our position is, based on the assumption that the order is headers > items > footers
    if (position < mHeaders.size()) {
        return RecyclerViewMode.MODE_HEADER_VIEW;
    } else if (position >= mHeaders.size() + mData.size()) {
        return RecyclerViewMode.MODE_FOOTER_VIEW;
    }
    return RecyclerViewMode.MODE_DATA;
}

3. GetItemCount विधि को हटा दें

@Override
public int getItemCount() {
    if (mMode == RecyclerViewMode.MODE_DATA) {
        return mData.size() + mHeaders.size() + mFooters.size();
    } else {
        return 1;
    }
}

4. OnCreateViewHolder विधि को हटा दें। viewType द्वारा व्यू होल्डर बनाएं

@Override
public RecyclerView.ViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
    if (viewType == RecyclerViewMode.MODE_LOADING) {
        RecyclerView.ViewHolder loadingViewHolder = onCreateLoadingViewHolder(parent);
        loadingViewHolder.itemView.setLayoutParams(
                new ViewGroup.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, parent.getHeight() - mToolBarHeight)
        );
        return loadingViewHolder;
    }
    if (viewType == RecyclerViewMode.MODE_ERROR) {
        RecyclerView.ViewHolder errorViewHolder = onCreateErrorViewHolder(parent);
        errorViewHolder.itemView.setLayoutParams(
                new ViewGroup.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, parent.getHeight() - mToolBarHeight)
        );
        errorViewHolder.itemView.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(final View v) {
                if (null != mOnErrorViewClickListener) {
                    new Handler().postDelayed(new Runnable() {
                        @Override
                        public void run() {
                            mOnErrorViewClickListener.onErrorViewClick(v);
                        }
                    }, 200);
                }
            }
        });
        return errorViewHolder;
    }
    if (viewType == RecyclerViewMode.MODE_EMPTY) {
        RecyclerView.ViewHolder emptyViewHolder = onCreateEmptyViewHolder(parent);
        emptyViewHolder.itemView.setLayoutParams(
                new ViewGroup.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, parent.getHeight() - mToolBarHeight)
        );
        emptyViewHolder.itemView.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(final View v) {
                if (null != mOnEmptyViewClickListener) {
                    new Handler().postDelayed(new Runnable() {
                        @Override
                        public void run() {
                            mOnEmptyViewClickListener.onEmptyViewClick(v);
                        }
                    }, 200);
                }
            }
        });
        return emptyViewHolder;
    }
    if (viewType == RecyclerViewMode.MODE_HEADER_VIEW) {
        RecyclerView.ViewHolder headerViewHolder = onCreateHeaderViewHolder(parent);
        headerViewHolder.itemView.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(final View v) {
                if (null != mOnHeaderViewClickListener) {
                    new Handler().postDelayed(new Runnable() {
                        @Override
                        public void run() {
                            mOnHeaderViewClickListener.onHeaderViewClick(v, v.getTag());
                        }
                    }, 200);
                }
            }
        });
        return headerViewHolder;
    }
    if (viewType == RecyclerViewMode.MODE_FOOTER_VIEW) {
        RecyclerView.ViewHolder footerViewHolder = onCreateFooterViewHolder(parent);
        footerViewHolder.itemView.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(final View v) {
                if (null != mOnFooterViewClickListener) {
                    new Handler().postDelayed(new Runnable() {
                        @Override
                        public void run() {
                            mOnFooterViewClickListener.onFooterViewClick(v, v.getTag());
                        }
                    }, 200);
                }
            }
        });
        return footerViewHolder;
    }
    RecyclerView.ViewHolder dataViewHolder = onCreateDataViewHolder(parent);
    dataViewHolder.itemView.setOnClickListener(new View.OnClickListener() {
        @Override
        public void onClick(final View v) {
            if (null != mOnItemClickListener) {
                new Handler().postDelayed(new Runnable() {
                    @Override
                    public void run() {
                        mOnItemClickListener.onItemClick(v, v.getTag());
                    }
                }, 200);
            }
        }
    });
    dataViewHolder.itemView.setOnLongClickListener(new View.OnLongClickListener() {
        @Override
        public boolean onLongClick(final View v) {
            if (null != mOnItemLongClickListener) {
                new Handler().postDelayed(new Runnable() {
                    @Override
                    public void run() {
                        mOnItemLongClickListener.onItemLongClick(v, v.getTag());
                    }
                }, 200);
                return true;
            }
            return false;
        }
    });
    return dataViewHolder;
}

5. OnBindViewHolder विधि को हटा दें। डेटा को बाइंड करके देखें

@Override
public void onBindViewHolder(RecyclerView.ViewHolder holder, int position) {
    if (mMode == RecyclerViewMode.MODE_LOADING) {
        onBindLoadingViewHolder(holder, position);
    } else if (mMode == RecyclerViewMode.MODE_ERROR) {
        onBindErrorViewHolder(holder, position);
    } else if (mMode == RecyclerViewMode.MODE_EMPTY) {
        onBindEmptyViewHolder(holder, position);
    } else {
        if (position < mHeaders.size()) {
            if (mHeaders.size() > 0) {
                onBindHeaderViewHolder(holder, position);
            }
        } else if (position >= mHeaders.size() + mData.size()) {
            if (mFooters.size() > 0) {
                onBindFooterViewHolder(holder, position - mHeaders.size() - mData.size());
            }
        } else {
            onBindDataViewHolder(holder, position - mHeaders.size());
        }
    }
}

क्या होगा यदि आपका लिंक भविष्य में टूट जाएगा?
गोपाल सिंह सिरवी

अच्छा सवाल। मैं अपना जवाब संपादित करूंगा और अपना कोड यहां पोस्ट करूंगा
yefeng

1

आप अपने सेक्शन में आइटमों को समूहीकृत करने के लिए लाइब्रेरी सेक्शनRecyclerViewAdapter का उपयोग कर सकते हैं और प्रत्येक सेक्शन में एक हेडर जोड़ सकते हैं, जैसे नीचे दी गई छवि पर:

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

पहले आप अपना सेक्शन क्लास बनाएँ:

class MySection extends StatelessSection {

    String title;
    List<String> list;

    public MySection(String title, List<String> list) {
        // call constructor with layout resources for this Section header, footer and items 
        super(R.layout.section_header, R.layout.section_item);

        this.title = title;
        this.list = list;
    }

    @Override
    public int getContentItemsTotal() {
        return list.size(); // number of items of this section
    }

    @Override
    public RecyclerView.ViewHolder getItemViewHolder(View view) {
        // return a custom instance of ViewHolder for the items of this section
        return new MyItemViewHolder(view);
    }

    @Override
    public void onBindItemViewHolder(RecyclerView.ViewHolder holder, int position) {
        MyItemViewHolder itemHolder = (MyItemViewHolder) holder;

        // bind your view here
        itemHolder.tvItem.setText(list.get(position));
    }

    @Override
    public RecyclerView.ViewHolder getHeaderViewHolder(View view) {
        return new SimpleHeaderViewHolder(view);
    }

    @Override
    public void onBindHeaderViewHolder(RecyclerView.ViewHolder holder) {
        MyHeaderViewHolder headerHolder = (MyHeaderViewHolder) holder;

        // bind your header view here
        headerHolder.tvItem.setText(title);
    }
}

फिर आप अपने अनुभागों के साथ RecyclerView सेट करें और एक GridLaybManager के साथ हेडर का स्पैनसाइज़ बदलें:

// Create an instance of SectionedRecyclerViewAdapter 
SectionedRecyclerViewAdapter sectionAdapter = new SectionedRecyclerViewAdapter();

// Create your sections with the list of data
MySection section1 = new MySection("My Section 1 title", dataList1);
MySection section2 = new MySection("My Section 2 title", dataList2);

// Add your Sections to the adapter
sectionAdapter.addSection(section1);
sectionAdapter.addSection(section2);

// Set up a GridLayoutManager to change the SpanSize of the header
GridLayoutManager glm = new GridLayoutManager(getContext(), 2);
glm.setSpanSizeLookup(new GridLayoutManager.SpanSizeLookup() {
    @Override
    public int getSpanSize(int position) {
        switch(sectionAdapter.getSectionItemViewType(position)) {
            case SectionedRecyclerViewAdapter.VIEW_TYPE_HEADER:
                return 2;
            default:
                return 1;
        }
    }
});

// Set up your RecyclerView with the SectionedRecyclerViewAdapter
RecyclerView recyclerView = (RecyclerView) findViewById(R.id.recyclerview);
recyclerView.setLayoutManager(glm);
recyclerView.setAdapter(sectionAdapter);

0

मुझे पता है कि मैं देर से आता हूं, लेकिन हाल ही में मैं एडेप्टर को इस तरह के "एडहेडर" को लागू करने में सक्षम था। मेरे फ्लेक्सिबल एडेप्टर प्रोजेक्ट में आप setHeaderएक सेलेबल आइटम पर कॉल कर सकते हैं , फिर आप कॉल कर सकते हैं showAllHeaders। यदि आपको केवल 1 हेडर चाहिए तो पहले आइटम में हेडर होना चाहिए। यदि आप इस आइटम को हटाते हैं, तो हेडर स्वचालित रूप से अगले एक से जुड़ा होता है।

दुर्भाग्य से फ़ुटर को कवर नहीं किया गया है (अभी तक)।

FlexibleAdapter आपको हेडर / अनुभाग बनाने की तुलना में बहुत अधिक करने की अनुमति देता है। आपको वास्तव में एक नज़र होना चाहिए: https://github.com/davideas/FlexibleAdapter


0

मैं बस उन सभी HeaderRecyclerViewAdapter कार्यान्वयन के लिए एक विकल्प जोड़ूंगा। CompoundAdapter:

https://github.com/negusoft/CompoundAdapter-android

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

AdapterGroup adapterGroup = new AdapterGroup();
adapterGroup.addAdapter(SingleAdapter.create(R.layout.header));
adapterGroup.addAdapter(new MyAdapter(...));

recyclerView.setAdapter(adapterGroup);

यह काफी सरल और पठनीय है। आप समान सिद्धांत का उपयोग करके अधिक जटिल एडॉप्टर को आसानी से लागू कर सकते हैं।

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