क्या कोई AddHeaderView RecyclerView के बराबर है?


290

मैं एक पुनर्नवीनीकरण दृश्य के लिए addHeaderView के बराबर के लिए देख रहा हूँ। मूल रूप से मैं चाहता हूं कि 2 बटन वाली छवि को हेडर के रूप में सूची में जोड़ा जाए। क्या एक पुनर्नवीनीकरण दृश्य में हेडर दृश्य जोड़ने का एक अलग तरीका है? मार्गदर्शन के लिए एक उदाहरण सहायक होगा

EDIT 2 (अतिरिक्त खंड लेआउट):

लॉग स्टेटमेंट्स को जोड़ने के बाद, ऐसा लगता है जैसे getViewType केवल 0. की स्थिति प्राप्त करता है। इससे ऑनक्रिएट व्यू केवल एक लेआउट लोड हो रहा है:

10-26 16:32:53.766    5449-5449/co.testapp I/logger info Adapter-> getItemCount: 5
10-26 16:32:53.766    5449-5449/co.testapp I/logger info Adapter-> getItemCount: 5
10-26 16:32:53.766    5449-5449/co.testapp I/logger info Adapter-> getItemCount: 5
10-26 16:32:53.766    5449-5449/co.testapp I/logger info Adapter-> getItemCount: 5
10-26 16:32:53.766    5449-5449/co.testapp I/logger info Adapter-> getItemCount: 5
10-26 16:32:53.766    5449-5449/co.testapp I/logger info Adapter-> getItemCount: 5
10-26 16:32:53.766    5449-5449/co.testapp I/logger info Adapter-> getItemCount: 5
10-26 16:32:53.766    5449-5449/co.testapp I/logger info Adapter-> getItemCount: 5
10-26 16:32:53.766    5449-5449/co.testapp I/logger info Adapter-> getItemCount: 5
10-26 16:32:53.766    5449-5449/co.testapp I/logger info Adapter-> getItemCount: 5
10-26 16:32:53.766    5449-5449/co.testapp I/logger info Adapter-> getItemCount: 5
10-26 16:32:53.766    5449-5449/co.testapp I/logger info Adapter-> getItemViewType position: 0
10-26 16:32:53.766    5449-5449/co.testapp I/logger info Adapter-> getItemViewType position: 0
10-26 16:32:53.766    5449-5449/co.testapp I/logger info Adapter-> getItemViewType position: 0
10-26 16:32:53.766    5449-5449/co.testapp I/logger info Adapter-> onCreateViewHolder, viewtype: 0
10-26 16:32:53.766    5449-5449/co.testapp I/logger info Adapter-> onBindViewHolder, viewType: 0

टिप्पणी संक्रमण लोड करने के लिए टुकड़ा संक्रमण:

@Override
public void onPhotoFeedItemClick(View view, int position) {
    if (fragmentManager == null)
        fragmentManager = getSupportFragmentManager();

FragmentTransaction fragmentTransaction = fragmentManager.beginTransaction();

    if (view.getId() == R.id.button_comment){
        CommentFragment commentFragment = CommentFragment.newInstance("","", position);
        fragmentTransaction.add(R.id.main_activity, commentFragment,"comment_fragment_tag");
        fragmentTransaction.addToBackStack(Constants.TAG_COMMENTS);
        fragmentTransaction.commit();
    }
}

फ्रैगमेंट का ऑनक्रिएट व्यू:

@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container,
                         Bundle savedInstanceState) {

    View view = inflater.inflate(R.layout.fragment_comment, container, false);
    mRecyclerView = (RecyclerView) view.findViewById(R.id.list_recylclerview);
    mRecyclerView.setLayoutManager(new LinearLayoutManager(_context));
    mRecyclerView.setItemAnimator(new DefaultItemAnimator());
    mAdapter = new CommentAdapter(R.layout.row_list_comments, R.layout.row_header_comments, _context, comments);
    mRecyclerView.setAdapter(mAdapter);
    return view;
}

पुनरावर्तन युक्त टुकड़ा:

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    tools:context="co.testapp.fragments.CommentFragment"
    android:background="@color/white">
        <RelativeLayout
            android:layout_width="fill_parent"
            android:layout_height="fill_parent"
            android:orientation="vertical">
            <android.support.v7.widget.RecyclerView
                xmlns:android="http://schemas.android.com/apk/res/android"
                android:id="@+id/list_recylclerview"
                android:layout_width="match_parent"
                android:layout_height="200dp" />
        </RelativeLayout>
</RelativeLayout>

टिप्पणियाँ पंक्ति लेआउट:

<?xml version="1.0" encoding="utf-8"?>

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical" android:layout_width="match_parent"
    android:layout_height="match_parent" android:layout_margin="10dp"
    android:background="@color/white">
    <!--Profile Picture-->
    <ImageView
        android:layout_width="80dp"
        android:layout_height="80dp"
        android:id="@+id/profile_picture"
        android:background="@color/blue_testapp"/>
    <!--Name-->
    <TextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_marginLeft="10dp"
        android:text="First Name Last Name"
        android:textSize="16dp"
        android:textColor="@color/blue_testapp"
        android:id="@+id/name_of_poster"
        android:layout_toRightOf="@id/profile_picture"
        />
    <!--Comment-->
    <TextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_margin="10dp"
        android:layout_marginTop="-5dp"
        android:text="This is a test comment"
        android:textSize="14dp"
        android:textColor="@color/black"
        android:id="@+id/comment"
        android:layout_below="@id/name_of_poster"
        android:layout_toRightOf="@id/profile_picture"/>
</RelativeLayout>

हेडर

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
              android:orientation="vertical"
              android:layout_width="match_parent"
              android:layout_height="match_parent">
    <ImageView
        android:layout_width="wrap_content"
        android:layout_height="300dp"
        android:id="@+id/header_photo"
        android:layout_gravity="center_horizontal"/>
</LinearLayout>

एडाप्टर कोड (मुझे शुरू करने के लिए उनके लिए धन्यवाद):

public class CommentAdapter extends RecyclerView.Adapter<ViewHolder>{

    private final int rowCardLayout;
    public static Context mContext;
    private final int headerLayout;
    private final String [] comments;
    private static final int HEADER = 0;
    private static final int OTHER = 0;

    public CommentAdapter(int rowCardLayout, int headerLayout, Context context, String [] comments) {
        this.rowCardLayout = rowCardLayout;
        this.mContext = context;
        this.comments = comments;
        this.headerLayout = headerLayout;
    }

    @Override
    public ViewHolder onCreateViewHolder(ViewGroup viewGroup, int i) {
        logger.i("onCreateViewHolder, viewtype: " + i); //viewtype always returns 0 so OTHER layout is never inflated
        if (i == HEADER) {
            View v = LayoutInflater.from(viewGroup.getContext()).inflate(headerLayout, viewGroup, false);
            return new ViewHolderHeader(v);
        }
        else if (i == OTHER){
            View v = LayoutInflater.from(viewGroup.getContext()).inflate(rowCardLayout, viewGroup, false);
            return new ViewHolderComments(v);
        }
        else 
          throw new RuntimeException("Could not inflate layout");
    }

    @Override
    public void onBindViewHolder(ViewHolder viewHolder, int i) {
        logger.i("onBindViewHolder, viewType: " + i);

        if (viewHolder instanceof ViewHolderComments)
            ((ViewHolderComments) viewHolder).comment.setText(comments[i].toString());
        if (viewHolder instanceof ViewHolderHeader)
           ((ViewHolderHeader) viewHolder).header.setImageResource(R.drawable.image2);
        else {
            logger.e("no instance of viewholder found");
        }
    }

    @Override
    public int getItemCount() {
        int count = comments.length + 1;
        logger.i("getItemCount: " + count);
        return count;
    }

    @Override
    public int getItemViewType(int position) {
        logger.i("getItemViewType position: " + position);
        if (position == HEADER)
            return HEADER;
        else
            return OTHER;
    }

    public static class ViewHolderComments extends RecyclerView.ViewHolder {
        public TextView comment;
        public ImageView image;

        public ViewHolderComments(View itemView) {
            super(itemView);
            comment = (TextView) itemView.findViewById(R.id.comment);
            image = (ImageView) itemView.findViewById(R.id.image);
        }
    }

    public static class ViewHolderHeader extends RecyclerView.ViewHolder {
        public final ImageView header;

        public ViewHolderHeader(View itemView){
            super(itemView);
            header = (ImageView) itemView.findViewById(R.id.header_photo);
        }
    }
}

इसके बाद के संस्करण कोड, केवल शीर्ष लेख लेआउट viewType के रूप में प्रदर्शित किया जाता है का उपयोग करना हमेशा 0. ऐसा लग रहा है है इस । यदि मैं अन्य लेआउट को इस तरह देखता हूं तो यह मजबूर करता है :



जैसा कि यह यहाँ प्रश्न का एक डुप्लिकेट है , मैंने अपना उत्तर वहाँ पोस्ट किया :
seb

जवाबों:


457

एक आसान तरीका नहीं है, listview.addHeaderView()लेकिन आप हेडर के लिए अपने एडॉप्टर में एक प्रकार जोड़कर इसे प्राप्त कर सकते हैं।

यहाँ एक उदाहरण है

public class HeaderAdapter extends RecyclerView.Adapter<RecyclerView.ViewHolder> {
    private static final int TYPE_HEADER = 0;
    private static final int TYPE_ITEM = 1;
    String[] data;

    public HeaderAdapter(String[] data) {
        this.data = data;
    }

    @Override
    public RecyclerView.ViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
        if (viewType == TYPE_ITEM) {
            //inflate your layout and pass it to view holder
            return new VHItem(null);
        } else if (viewType == TYPE_HEADER) {
            //inflate your layout and pass it to view holder
            return new VHHeader(null);
        }

        throw new RuntimeException("there is no type that matches the type " + viewType + " + make sure your using types correctly");
    }

    @Override
    public void onBindViewHolder(RecyclerView.ViewHolder holder, int position) {
        if (holder instanceof VHItem) {
            String dataItem = getItem(position);
            //cast holder to VHItem and set data
        } else if (holder instanceof VHHeader) {
            //cast holder to VHHeader and set data for header.
        }
    }

    @Override
    public int getItemCount() {
        return data.length + 1;
    }

    @Override
    public int getItemViewType(int position) {
        if (isPositionHeader(position))
            return TYPE_HEADER;

        return TYPE_ITEM;
    }

    private boolean isPositionHeader(int position) {
        return position == 0;
    }

    private String getItem(int position) {
        return data[position - 1];
    }

    class VHItem extends RecyclerView.ViewHolder {
        TextView title;

        public VHItem(View itemView) {
            super(itemView);
        }
    }

    class VHHeader extends RecyclerView.ViewHolder {
        Button button;

        public VHHeader(View itemView) {
            super(itemView);
        }
    }
}

जिस्ट से लिंक करें -> यहां


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

1
एक बंदूक के सूर्य, रिसाइकलवेरी की सफाई और मैच माता-पिता को जोड़ने का काम किया .... मदद के लिए बहुत बहुत धन्यवाद! जितनी जल्दी हो सके मैं तुम्हें उखाड़ फेकूंगा।
विक्सीडायर

14
private String getItem(int position) { return data[position + 1]; }एक एनपीई का कारण बनता है। चूंकि हेडर के कारण हमारी स्थिति एक हो गई है, इसलिए हमें अपने डेटा [] से सही आइटम प्राप्त करने के लिए 1 को घटाना होगा। private String getItem(int position) { return data[position - 1]; }
टिम मलसीद

2
यदि आपका ग्रिड सिर्फ एक साधारण ग्रिड है, तो केवल LinearLayoutManager का उपयोग करें और एक पंक्ति में आइटम को दिखाएं। इसकी बकेट बाइट पंक्ति जिसे मैंने देखा है कि Google अपने कुछ ऐप में इसका उपयोग करता है।
EC84B4

4
आप इस दृष्टिकोण का उपयोग कर सकते हैं और साथ ही @nsL जोड़ने setSpanSizeLookupके लिए GridLayoutManagerहै, तो आपके हैडर कॉलम के सभी ले जाएगा
दिमित्री Zaytsev

62

आसान और पुन: प्रयोज्य ItemDecoration

स्थैतिक हेडर आसानी से एक ItemDecorationऔर बिना किसी और बदलाव के साथ जोड़ा जा सकता है

// add the decoration. done.
HeaderDecoration headerDecoration = new HeaderDecoration(/* init */);
recyclerView.addItemDecoration(headerDecoration);

सजावट भी पुन: प्रयोज्य है क्योंकि एडेप्टर को संशोधित करने की आवश्यकता नहीं है या RecyclerViewबिल्कुल भी नहीं है।

नीचे दिए गए नमूना कोड को शीर्ष पर जोड़ने के लिए एक दृश्य की आवश्यकता होगी जो कि सब कुछ की तरह फुलाया जा सकता है। यह इस तरह दिख सकता है:

शीर्षासन नमूना

स्थिर क्यों ?

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

खाली सूची हैंडलिंग

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

कोड

आप GitHub पर पूर्ण स्रोत कोड पा सकते हैं जिसमें Builderडेकोरेटर के आरंभीकरण में मदद करना शामिल है, या बस नीचे दिए गए कोड का उपयोग करें और निर्माणकर्ता को अपने स्वयं के मूल्यों की आपूर्ति करें।

कृपया layout_heightअपने विचार के लिए एक सही सेट करना सुनिश्चित करें । उदाहरण के match_parentलिए ठीक से काम नहीं कर सकते हैं।

public class HeaderDecoration extends RecyclerView.ItemDecoration {

    private final View mView;
    private final boolean mHorizontal;
    private final float mParallax;
    private final float mShadowSize;
    private final int mColumns;
    private final Paint mShadowPaint;

    public HeaderDecoration(View view, boolean scrollsHorizontally, float parallax, float shadowSize, int columns) {
        mView = view;
        mHorizontal = scrollsHorizontally;
        mParallax = parallax;
        mShadowSize = shadowSize;
        mColumns = columns;

        if (mShadowSize > 0) {
            mShadowPaint = new Paint();
            mShadowPaint.setShader(mHorizontal ?
                    new LinearGradient(mShadowSize, 0, 0, 0,
                            new int[]{Color.argb(55, 0, 0, 0), Color.argb(55, 0, 0, 0), Color.argb(3, 0, 0, 0)},
                            new float[]{0f, .5f, 1f},
                            Shader.TileMode.CLAMP) :
                    new LinearGradient(0, mShadowSize, 0, 0,
                            new int[]{Color.argb(55, 0, 0, 0), Color.argb(55, 0, 0, 0), Color.argb(3, 0, 0, 0)},
                            new float[]{0f, .5f, 1f},
                            Shader.TileMode.CLAMP));
        } else {
            mShadowPaint = null;
        }
    }

    @Override
    public void onDraw(Canvas c, RecyclerView parent, RecyclerView.State state) {
        super.onDraw(c, parent, state);
        // layout basically just gets drawn on the reserved space on top of the first view
        mView.layout(parent.getLeft(), 0, parent.getRight(), mView.getMeasuredHeight());

        for (int i = 0; i < parent.getChildCount(); i++) {
            View view = parent.getChildAt(i);
            if (parent.getChildAdapterPosition(view) == 0) {
                c.save();
                if (mHorizontal) {
                    c.clipRect(parent.getLeft(), parent.getTop(), view.getLeft(), parent.getBottom());
                    final int width = mView.getMeasuredWidth();
                    final float left = (view.getLeft() - width) * mParallax;
                    c.translate(left, 0);
                    mView.draw(c);
                    if (mShadowSize > 0) {
                        c.translate(view.getLeft() - left - mShadowSize, 0);
                        c.drawRect(parent.getLeft(), parent.getTop(), mShadowSize, parent.getBottom(), mShadowPaint);
                    }
                } else {
                    c.clipRect(parent.getLeft(), parent.getTop(), parent.getRight(), view.getTop());
                    final int height = mView.getMeasuredHeight();
                    final float top = (view.getTop() - height) * mParallax;
                    c.translate(0, top);
                    mView.draw(c);
                    if (mShadowSize > 0) {
                        c.translate(0, view.getTop() - top - mShadowSize);
                        c.drawRect(parent.getLeft(), parent.getTop(), parent.getRight(), mShadowSize, mShadowPaint);
                    }
                }
                c.restore();
                break;
            }
        }
    }

    @Override
    public void getItemOffsets(Rect outRect, View view, RecyclerView parent, RecyclerView.State state) {
        if (parent.getChildAdapterPosition(view) < mColumns) {
            if (mHorizontal) {
                if (mView.getMeasuredWidth() <= 0) {
                    mView.measure(View.MeasureSpec.makeMeasureSpec(parent.getMeasuredWidth(), View.MeasureSpec.AT_MOST),
                            View.MeasureSpec.makeMeasureSpec(parent.getMeasuredHeight(), View.MeasureSpec.AT_MOST));
                }
                outRect.set(mView.getMeasuredWidth(), 0, 0, 0);
            } else {
                if (mView.getMeasuredHeight() <= 0) {
                    mView.measure(View.MeasureSpec.makeMeasureSpec(parent.getMeasuredWidth(), View.MeasureSpec.AT_MOST),
                            View.MeasureSpec.makeMeasureSpec(parent.getMeasuredHeight(), View.MeasureSpec.AT_MOST));
                }
                outRect.set(0, mView.getMeasuredHeight(), 0, 0);
            }
        } else {
            outRect.setEmpty();
        }
    }
}

कृपया ध्यान दें: GitHub परियोजना मेरा व्यक्तिगत खेल का मैदान है। यह थोरौली परीक्षण नहीं है, यही वजह है कि अभी तक कोई पुस्तकालय नहीं है

यह क्या करता है?

एक ItemDecorationसूची के एक आइटम के लिए अतिरिक्त ड्राइंग है। इस मामले में, पहले आइटम के शीर्ष पर एक सजावट तैयार की जाती है।

दृश्य मापा और बिछाया जाता है, फिर इसे पहले आइटम के शीर्ष पर खींचा जाता है। यदि एक लंबन प्रभाव जोड़ा जाता है, तो इसे सही सीमा में भी जोड़ा जाएगा।


1
एक सुंदर समाधान दिखता है, लेकिन, मेरे पास एक सवाल है: मुझे recyclerView.addItemDecoration कब कॉल करना चाहिए?
वीबो

1
धन्यवाद, यह ठीक काम किया! इस पद्धति का उपयोग करने के लिए एकमात्र नकारात्मक पहलू यह है कि आपको RecyclerView में कम से कम 1 पंक्ति होनी चाहिए।
फिलिप गिउलियानी

3
हेडर के लिए onClickListener कैसे करें?
प्रशांत केडिया

1
मैं निम्नलिखित अपवाद प्राप्त कर रहा हूं: java.lang.NullPointerException: आभासी पद्धति 'बूलियन android.support.v7.widget.RecyclerView $ ViewHolder.shouldIgnore ()' को एक अशक्त वस्तु संदर्भ में
संलग्न करने का प्रयास

1
क्या सजावट में विचारों तक पहुंचने का कोई तरीका है? मैं पाठ को गतिशील रूप से सेट करना चाहता हूं।
SMahdiS

44

यहां उपलब्ध मेरे पुस्तकालय का उपयोग करने के लिए स्वतंत्र महसूस करें ।

यह है कि आप Viewकिसी भी RecyclerViewउपयोग करने वाले LinearLayoutManagerया GridLayoutManagerकेवल एक सरल विधि कॉल के लिए हेडर बनाते हैं ।

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


हेडर की ऊंचाई कैसे बदलें?
50सौरभ

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

क्या आपको लगता है कि आप जिस मुद्दे का वर्णन कर रहे हैं, वह इससे संबंधित हो सकता है: github.com/blipinsk/RecyclerViewHeader/issues/16 ?
बार्टेक लिपिंस्की

लिपिंस्की ने इस लाइब्रेरी को रिटायर कर दिया है और इसके बजाय इसका उपयोग करने का सुझाव देता है: github.com/Karumi/HeaderRecyclerView
radley

1
मैं इस लाइब्रेरी को सटीक होने के लिए रिटायर कर रहा हूं । मैं अभी भी इसके लिए एक हल्का समर्थन प्रदान कर रहा हूं, लेकिन वास्तव में मैं इसके बजाय विशेष एडाप्टर के साथ जाने का सुझाव दे रहा हूं (जैसे कि कारुमी से एक)।
बार्टेक लिपिंस्की

31

आपको एक पुनर्नवीनीकरण दृश्य में आइटम के साथ हेडर बनाने के लिए दिखाने के लिए जा रहा है।हैडर के साथ रिसाइक्लर व्यू

चरण 1- अपने ग्रेड फ़ाइल में निर्भरता जोड़ें।

compile 'com.android.support:recyclerview-v7:23.2.0'
// CardView
compile 'com.android.support:cardview-v7:23.2.0'

कार्डव्यू का उपयोग सजावट के उद्देश्य के लिए किया जाता है।

स्टेप2- तीन xml फाइल बनाएं। मुख्य गतिविधि के लिए एक। हैडर लेआउट के लिए। सूची आइटम लेआउट के लिए।

activity_main.xml

<android.support.v7.widget.RecyclerView
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:id="@+id/my_recycler_view"
    android:scrollbars="vertical"
    android:layout_width="match_parent"
    android:layout_height="match_parent" />

header.xml

<android.support.v7.widget.CardView
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    app:cardElevation="2dp">

    <TextView
        android:id="@+id/txtHeader"
        android:gravity="center"
        android:textColor="#000000"
        android:textSize="@dimen/abc_text_size_large_material"
        android:background="#DCDCDC"
        android:layout_width="match_parent"
        android:layout_height="50dp" />

</android.support.v7.widget.CardView>

list.xml

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

    <android.support.v7.widget.CardView
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        app:cardElevation="1dp">

        <TextView
            android:id="@+id/txtName"
            android:text="abc"
            android:layout_width="match_parent"
            android:layout_height="wrap_content" />

    </android.support.v7.widget.CardView>

</LinearLayout>

चरण 3- तीन बीन कक्षाएं बनाएं।

Header.java

public class Header extends ListItem {
    private String header;

    public String getHeader() {
        return header;
    }
    public void setHeader(String header) {
        this.header = header;
    }
}

ContentItem.java

public class ContentItem extends ListItem {

    private String name;
    private String rollnumber;

    @Override
    public String getName() {
        return name;
    }

    @Override
    public void setName(String name) {
        this.name = name;
    }

    public String getRollnumber() {
        return rollnumber;
    }

    public void setRollnumber(String rollnumber) {
        this.rollnumber = rollnumber;
    }
}

ListItem.java

public class ListItem {
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    private int id;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }
}

स्टेप 4- MyRecyclerAdapter.java नाम से एडॉप्टर बनाएं

public class MyRecyclerAdapter extends  RecyclerView.Adapter<RecyclerView.ViewHolder> {
    private static final int TYPE_HEADER = 0;
    private static final int TYPE_ITEM = 1;

    //Header header;
    List<ListItem> list;
    public MyRecyclerAdapter(List<ListItem> headerItems) {
        this.list = headerItems;
    }

    @Override
    public RecyclerView.ViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
        LayoutInflater inflater = LayoutInflater.from(parent.getContext());
        if (viewType == TYPE_HEADER) {
            View v = inflater.inflate(R.layout.header, parent, false);
            return  new VHHeader(v);
        } else {
            View v = inflater.inflate(R.layout.list, parent, false);
            return new VHItem(v);
        }
        throw new IllegalArgumentException();
    }

    @Override
    public void onBindViewHolder(RecyclerView.ViewHolder holder, int position) {
        if (holder instanceof VHHeader) {
           // VHHeader VHheader = (VHHeader)holder;
            Header  currentItem = (Header) list.get(position);
            VHHeader VHheader = (VHHeader)holder;
            VHheader.txtTitle.setText(currentItem.getHeader());
        } else if (holder instanceof VHItem) 
            ContentItem currentItem = (ContentItem) list.get(position);
            VHItem VHitem = (VHItem)holder;
            VHitem.txtName.setText(currentItem.getName());
        }
    }

    @Override
    public int getItemViewType(int position) {
        if (isPositionHeader(position))
            return TYPE_HEADER;
        return TYPE_ITEM;
    }

    private boolean isPositionHeader(int position) {
        return list.get(position) instanceof Header;
    }

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

    class VHHeader extends RecyclerView.ViewHolder{
        TextView txtTitle;
        public VHHeader(View itemView) {
            super(itemView);
            this.txtTitle = (TextView) itemView.findViewById(R.id.txtHeader);
        }
    }
    class VHItem extends RecyclerView.ViewHolder{
        TextView txtName;
        public VHItem(View itemView) {
            super(itemView);
            this.txtName = (TextView) itemView.findViewById(R.id.txtName);
        }
    }
}

चरण 5- मेनएक्टिविटी में निम्नलिखित कोड जोड़ें:

public class MainActivity extends AppCompatActivity {
    RecyclerView recyclerView;
    List<List<ListItem>> arraylist;
    MyRecyclerAdapter adapter;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        recyclerView = (RecyclerView)findViewById(R.id.my_recycler_view);
        LinearLayoutManager linearLayoutManager = new LinearLayoutManager(this);
        adapter = new MyRecyclerAdapter(getList());
        recyclerView.setLayoutManager(linearLayoutManager);
        recyclerView.setAdapter(adapter);
    }

    private ArrayList<ListItem> getList() {
        ArrayList<ListItem> arrayList = new ArrayList<>();
        for(int j = 0; j <= 4; j++) {
            Header header = new Header();
            header.setHeader("header"+j);
            arrayList.add(header);
            for (int i = 0; i <= 3; i++) {
                ContentItem item = new ContentItem();
                item.setRollnumber(i + "");
                item.setName("A" + i);
                arrayList.add(item);
            }
        }
        return arrayList;
    }

}

फ़ंक्शन getList () गतिशील रूप से हेडर के लिए और सूची आइटम के लिए डेटा उत्पन्न कर रहा है।


सबसे अच्छा जवाब में से एक। मैंने नेविगेशन मेनू के लिए नेविगेशन
सौरभ भंडारी

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

8

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

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

1) एक कस्टम सेक्शन क्लास बनाएँ:

class MySection extends StatelessSection {

    List<String> myList = Arrays.asList(new String[] {"Item1", "Item2", "Item3" });

    public MySection() {
        // call constructor with layout resources for this Section header, footer and items 
        super(R.layout.section_header, R.layout.section_footer,  R.layout.section_item);
    }

    @Override
    public int getContentItemsTotal() {
        return myList.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(myList.get(position));
    }
}

2) आइटम के लिए एक कस्टम ViewHolder बनाएँ:

class MyItemViewHolder extends RecyclerView.ViewHolder {

    private final TextView tvItem;

    public MyItemViewHolder(View itemView) {
        super(itemView);

        tvItem = (TextView) itemView.findViewById(R.id.tvItem);
    }
}

3) अपने ReclyclerView को SeedRecyclerViewAdapter के साथ सेट करें

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

MySection mySection = new MySection();

// Add your Sections
sectionAdapter.addSection(mySection);

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

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

6

आप अपने शीर्ष लेख और अपने RecyclerView को NestedScrollView में रख सकते हैं:

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

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

        <include
            layout="@layout/your_header"/>

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

    </LinearLayout>

</android.support.v4.widget.NestedScrollView>

स्क्रॉल करने के लिए सही ढंग से काम करने के लिए, आपको अपने RecyclerView पर नेस्टेड स्क्रॉलिंग को अक्षम करना होगा:

myRecyclerView.setNestedScrollingEnabled(false);

3
या Android का उपयोग करें: nestedScrollingEnabled = "false"
radley

Android: nestedScrollingEnabled = "false" के लिए एपीआई स्तर 21 की आवश्यकता होती है, जो बेकार है। वैसे भी महान समाधान! वही आपको एक और पाद या शायद दूसरा पुनरावर्तन भी जोड़ना होगा?
माकलेले

47
कभी ऐसा मत करो। यह ठीक काम करने लगता है। लेकिन यह वास्तव में क्या करता है यह स्क्रॉल को srollView में पास करता है। तो recyclerView अपने दम पर कुछ भी नहीं करता है। पुनर्चक्रण नहीं देखें। यदि आप अपने पुनर्नवीनीकरण दृश्य में बहुत अधिक आइटम प्राप्त करते हैं तो ऐप क्रैश हो जाएगा क्योंकि अब यह एक साधारण स्क्रॉलव्यू की तरह काम कर रहा है।
विपुलकुमार

2
@ विपुलकुमार की टिप्पणी पूरी तरह से सत्य है। जब आप एक और स्क्रॉलव्यू के अंदर recyclerview का उपयोग करते हैं तो कोई रीसाइक्लिंग नहीं होगी और यह सभी आइटम बनाएगा।
VolkanSahin45

आप ऐसा कर सकते हैं यदि recyclerView में आपके आइटम 10. your से कम हैं
JIE WANG

5

नेटिव एपीआई में ऐसी "ऐडहेडर" सुविधा नहीं है, लेकिन इसमें "एड इट" की अवधारणा है।

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

यहाँ वे कैसे काम करते हैं:

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

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

उनके बारे में कहने के लिए बहुत कुछ है, विस्तृत विकी पृष्ठ को पढ़ने के लिए बेहतर है ।

इसके अलावा FlexibleAdapter आपको हेडर / सेक्शन बनाने की अनुमति देता है, साथ ही आप उन्हें अन्य मदों की तरह चिपचिपा और दसियों फीचर्स भी दे सकते हैं , अंतहीन स्क्रॉल, यूआई एक्सटेंशन आदि ... सभी एक पुस्तकालय में!


4

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

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

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

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


2

एक और समाधान है जो उपरोक्त सभी उपयोग मामलों को कवर करता है: CompoundAdapter: https://github.com/negusoft/CompoundAdapter-android

आप एक एडेप्टरग्रुप बना सकते हैं जो आपके एडेप्टर को रखता है जैसे कि हेडर का प्रतिनिधित्व करने के लिए एकल आइटम के साथ एक एडेप्टर। कोड आसान और पठनीय है:

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

recyclerView.setAdapter(adapterGroup);

एडॉप्टरग्रुप भी नेस्टिंग की अनुमति देता है, इसलिए सेक्शन वाले एडेप्टर के लिए, आप प्रति सेक्शन एडॉप्टरग्रुप बना सकते हैं। फिर सभी अनुभागों को एक रूट एडॉप्टरग्रुप में रखें।


1

HeaderView LayoutManager पर निर्भर करता है। कोई भी डिफॉल्ट लेआउटमैन इस का समर्थन नहीं करता है और शायद अभ्यस्त भी नहीं होता है। ListView में HeaderView बिना किसी महत्वपूर्ण लाभ के बहुत अधिक जटिलता पैदा करता है।

मैं एक आधार एडेप्टर वर्ग बनाने का सुझाव दूंगा जो प्रदान किए जाने पर हेडर के लिए आइटम जोड़ता है। हेडर मौजूद है या नहीं, इसके आधार पर उन्हें ठीक से ऑफसेट करने के लिए अधिसूचित * तरीकों को ओवरराइड करना न भूलें।


क्या कोई उदाहरण है जो आप मुझे बता सकते हैं कि एक आधार एडेप्टर के साथ एक पुनर्नवीनीकरण दृश्य का उपयोग करता है? धन्यवाद!
विक्सीरॉइड

एक सूची में हेडर / पाद के लिए वास्तव में महत्वपूर्ण लाभ है: आप इसे दृश्य से बाहर स्क्रॉल कर सकते हैं। इस उदाहरण को देखें जहां पिंगिन्स के बाहर निकलते ही दृश्य पंक्तियों की मात्रा लगभग दोगुनी हो जाती है , मुझे ऐसा करने के किसी अन्य तरीके के बारे में पता नहीं है, लेकिन ListView.addHeaderViewया इस प्रश्न का उत्तर।
ट्वीस्टेरोब

मुझे नहीं लगता कि मुझे यह सही लगता है। यदि यह एडॉप्टर में पहला आइटम है, तो इसे उदाहरण में एक की तरह स्क्रॉल क्यों नहीं किया जा सकता है?
21

2
आप सूचित * विधियों को ओवरराइड नहीं कर सकते, क्योंकि वे अंतिम रूप में चिह्नित हैं।
Mato

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

1
First - extends RecyclerView.Adapter<RecyclerView.ViewHolder>

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

के बाद - इस विधि को ओवरराइड करें GetItemViewTpe *** अधिक महत्वपूर्ण

@Override
public int getItemViewType(int position) {
    return position;
}

विधि onCreateViewHolder

@Override
public RecyclerView.ViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
    View view = LayoutInflater.from(parent.getContext()).inflate(R.layout.menu_item, parent, false);
    View header = LayoutInflater.from(parent.getContext()).inflate(R.layout.menu_header_item, parent, false);
    Log.d("onCreateViewHolder", String.valueOf(viewType));

    if (viewType == 0) {
        return new MenuLeftHeaderViewHolder(header, onClickListener);
    } else {
        return new MenuLeftViewHolder(view, onClickListener);
    }
}

विधि onBindViewHolder

@Override
public void onBindViewHolder(RecyclerView.ViewHolder holder, int position) {
    if (position == 0) {
        MenuHeaderViewHolder menuHeaderViewHolder = (MenuHeaderViewHolder) holder;
        menuHeaderViewHolder.mTitle.setText(sMenuTitles[position]);
        menuHeaderViewHolder.mImage.setImageResource(sMenuImages[position]);
    } else {
        MenuViewHolder menuLeftViewHolder = (MenuLeftViewHolder) holder;
        menuViewHolder.mTitle.setText(sMenuTitles[position]);
        menuViewHolder.mImage.setImageResource(sMenuImages[position]);
    }
}

खत्म में ViewHolders वर्ग स्थिर लागू करता है

public static class MenuViewHolder extends RecyclerView.ViewHolder 

public static class MenuLeftHeaderViewHolder extends RecyclerView.ViewHolder 

1

यहाँ recyclerview के लिए कुछ आइटम डिडेक्यूलेशन

public class HeaderItemDecoration extends RecyclerView.ItemDecoration {

private View customView;

public HeaderItemDecoration(View view) {
    this.customView = view;
}

@Override
public void onDraw(Canvas c, RecyclerView parent, RecyclerView.State state) {
    super.onDraw(c, parent, state);
    customView.layout(parent.getLeft(), 0, parent.getRight(), customView.getMeasuredHeight());
    for (int i = 0; i < parent.getChildCount(); i++) {
        View view = parent.getChildAt(i);
        if (parent.getChildAdapterPosition(view) == 0) {
            c.save();
            final int height = customView.getMeasuredHeight();
            final int top = view.getTop() - height;
            c.translate(0, top);
            customView.draw(c);
            c.restore();
            break;
        }
    }
}

@Override
public void getItemOffsets(Rect outRect, View view, RecyclerView parent, RecyclerView.State state) {
    if (parent.getChildAdapterPosition(view) == 0) {
        customView.measure(View.MeasureSpec.makeMeasureSpec(parent.getMeasuredWidth(), View.MeasureSpec.AT_MOST),
                View.MeasureSpec.makeMeasureSpec(parent.getMeasuredHeight(), View.MeasureSpec.AT_MOST));
        outRect.set(0, customView.getMeasuredHeight(), 0, 0);
    } else {
        outRect.setEmpty();
    }
}
}      

1

मैंने @ हेटर के आधार पर एक कार्यान्वयन किया अपने व्यक्तिगत उद्देश्यों के लिए , लेकिन विरासत का उपयोग करके।

मैं अडॉप्टर सुपर क्लास में कार्यान्वयन विवरण तंत्र (जैसे 1 से जोड़ itemCount, घटाना 1 position) को छिपाता हूं , HeadingableRecycleAdapterजैसे एडेप्टर से आवश्यक विधियों को लागू करके onBindViewHolder, getItemViewTypeऔर getItemCount, उस विधियों को अंतिम रूप देता हूं, और क्लाइंट को छिपे हुए तर्क के साथ नए तरीके प्रदान करता हूं:

  • onAddViewHolder(RecyclerView.ViewHolder holder, int position),
  • onCreateViewHolder(ViewGroup parent),
  • itemCount()

यहां HeadingableRecycleAdapterक्लास और क्लाइंट हैं। मैंने हेडर लेआउट को थोड़ा हार्ड-कोडित छोड़ दिया क्योंकि यह मेरी आवश्यकताओं के अनुरूप है।

public abstract class HeadingableRecycleAdapter extends RecyclerView.Adapter<RecyclerView.ViewHolder> {

    private static final int HEADER_VIEW_TYPE = 0;

    @LayoutRes
    private int headerLayoutResource;
    private String headerTitle;
    private Context context;

    public HeadingableRecycleAdapter(@LayoutRes int headerLayoutResourceId, String headerTitle, Context context) {
        this.headerLayoutResource = headerLayoutResourceId;
        this.headerTitle = headerTitle;
        this.context = context;
    }

    public Context context() {
        return context;
    }

    @Override
    public final RecyclerView.ViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
        if (viewType == HEADER_VIEW_TYPE) {
            return new HeaderViewHolder(LayoutInflater.from(context).inflate(headerLayoutResource, parent, false));
        }
        return onCreateViewHolder(parent);
    }

    @Override
    public final void onBindViewHolder(RecyclerView.ViewHolder holder, int position) {
        int viewType = getItemViewType(position);
        if (viewType == HEADER_VIEW_TYPE) {
            HeaderViewHolder vh = (HeaderViewHolder) holder;
            vh.bind(headerTitle);
        } else {
            onAddViewHolder(holder, position - 1);
        }
    }

    @Override
    public final int getItemViewType(int position) {
        return position == 0 ? 0 : 1;
    }

    @Override
    public final int getItemCount() {
        return itemCount() + 1;
    }

    public abstract int itemCount();

    public abstract RecyclerView.ViewHolder onCreateViewHolder(ViewGroup parent);

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

}



@PerActivity
public class IngredientsAdapter extends HeadingableRecycleAdapter {
    public static final String TITLE = "Ingredients";
    private List<Ingredient> itemList;


    @Inject
    public IngredientsAdapter(Context context) {
        super(R.layout.layout_generic_recyclerview_cardified_header, TITLE, context);
    }

    public void setItemList(List<Ingredient> itemList) {
        this.itemList = itemList;
    }

    @Override
    public RecyclerView.ViewHolder onCreateViewHolder(ViewGroup parent) {
        return new ViewHolder(LayoutInflater.from(context()).inflate(R.layout.item_ingredient, parent, false));
    }

    @Override
    public void onAddViewHolder(RecyclerView.ViewHolder holder, int position) {
        ViewHolder vh = (ViewHolder) holder;
        vh.bind(itemList.get(position));
    }

    @Override
    public int itemCount() {
        return itemList == null ? 0 : itemList.size();
    }

    private String getQuantityFormated(double quantity, String measure) {
        if (quantity == (long) quantity) {
            return String.format(Locale.US, "%s %s", String.valueOf(quantity), measure);
        } else {
            return String.format(Locale.US, "%.1f %s", quantity, measure);
        }
    }


    class ViewHolder extends RecyclerView.ViewHolder {
        @BindView(R.id.text_ingredient)
        TextView txtIngredient;

        ViewHolder(View itemView) {
            super(itemView);
            ButterKnife.bind(this, itemView);
        }

        void bind(Ingredient ingredient) {
            String ingredientText = ingredient.getIngredient();
            txtIngredient.setText(String.format(Locale.US, "%s %s ", getQuantityFormated(ingredient.getQuantity(),
                    ingredient.getMeasure()), Character.toUpperCase(ingredientText.charAt(0)) +
                    ingredientText
                            .substring(1)));
        }
    }
}

1

हो सकता है कि एक कोर्डिनेटरलेआउट में हेडर और रिसाइकलव्यू लपेटें :

<android.support.design.widget.CoordinatorLayout
xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:app="http://schemas.android.com/apk/res-auto"
android:layout_width="match_parent"
android:layout_height="match_parent">

<android.support.design.widget.AppBarLayout
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    app:elevation="0dp">

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

</android.support.design.widget.AppBarLayout>

<android.support.v7.widget.RecyclerView
    android:id="@+id/list"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    app:layout_behavior="@string/appbar_scrolling_view_behavior" />


इसके साथ समस्या यह है कि यह हमेशा AppBarLayout की ऊंचाई तक स्क्रॉल करने की अनुमति देगा, भले ही सूची स्क्रीन से कम हो। यह तय करने के लिए कि आप यहाँ
डैनियल लोपेज़ लैक्लेले

0

संभवतः http://alexzh.com/tutorials/multiple-row-layouts-using-recyclerview/ मदद करेगा। यह केवल RecyclerView और CardView का उपयोग करता है। यहाँ एक एडाप्टर है:

public class DifferentRowAdapter extends RecyclerView.Adapter<RecyclerView.ViewHolder> {
    private List<CityEvent> mList;
    public DifferentRowAdapter(List<CityEvent> list) {
        this.mList = list;
    }
    @Override
    public RecyclerView.ViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
        View view;
        switch (viewType) {
            case CITY_TYPE:
                view = LayoutInflater.from(parent.getContext()).inflate(R.layout.item_city, parent, false);
                return new CityViewHolder(view);
            case EVENT_TYPE:
                view = LayoutInflater.from(parent.getContext()).inflate(R.layout.item_event, parent, false);
                return new EventViewHolder(view);
        }
        return null;
    }
    @Override
    public void onBindViewHolder(RecyclerView.ViewHolder holder, int position) {
        CityEvent object = mList.get(position);
        if (object != null) {
            switch (object.getType()) {
                case CITY_TYPE:
                    ((CityViewHolder) holder).mTitle.setText(object.getName());
                    break;
                case EVENT_TYPE:
                    ((EventViewHolder) holder).mTitle.setText(object.getName());
                    ((EventViewHolder) holder).mDescription.setText(object.getDescription());
                    break;
            }
        }
    }
    @Override
    public int getItemCount() {
        if (mList == null)
            return 0;
        return mList.size();
    }
    @Override
    public int getItemViewType(int position) {
        if (mList != null) {
            CityEvent object = mList.get(position);
            if (object != null) {
                return object.getType();
            }
        }
        return 0;
    }
    public static class CityViewHolder extends RecyclerView.ViewHolder {
        private TextView mTitle;
        public CityViewHolder(View itemView) {
            super(itemView);
            mTitle = (TextView) itemView.findViewById(R.id.titleTextView);
        }
    }
    public static class EventViewHolder extends RecyclerView.ViewHolder {
        private TextView mTitle;
        private TextView mDescription;
        public EventViewHolder(View itemView) {
            super(itemView);
            mTitle = (TextView) itemView.findViewById(R.id.titleTextView);
            mDescription = (TextView) itemView.findViewById(R.id.descriptionTextView);
        }
    }
}

और यहाँ एक इकाई है:

public class CityEvent {
    public static final int CITY_TYPE = 0;
    public static final int EVENT_TYPE = 1;
    private String mName;
    private String mDescription;
    private int mType;
    public CityEvent(String name, String description, int type) {
        this.mName = name;
        this.mDescription = description;
        this.mType = type;
    }
    public String getName() {
        return mName;
    }
    public void setName(String name) {
        this.mName = name;
    }
    public String getDescription() {
        return mDescription;
    }
    public void setDescription(String description) {
        this.mDescription = description;
    }
    public int getType() {
        return mType;
    }
    public void setType(int type) {
        this.mType = type;
    }
}

0

आप addHeaderView बना सकते हैं और उपयोग कर सकते हैं

adapter.addHeaderView(View)

यह कोड addHeaderViewएक से अधिक हेडर के लिए बनाता है। हेडर होना चाहिए:

android:layout_height="wrap_content"

public class MyAdapter extends RecyclerView.Adapter<RecyclerView.ViewHolder> {
    private static final int TYPE_ITEM = -1;
    public class MyViewSHolder extends RecyclerView.ViewHolder {
        public MyViewSHolder (View view) {
            super(view);
        }
        // put you code. for example:
        View mView;
        ...
    }

    public class ViewHeader extends RecyclerView.ViewHolder {
        public ViewHeader(View view) {
            super(view);
        }
    }

    private List<View> mHeaderViews = new ArrayList<>();
    public void addHeaderView(View headerView) {
        mHeaderViews.add(headerView);
    }

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

    @Override
    public int getItemViewType(int position) {
        if (mHeaderViews.size() > position) {
            return position;
        }

        return TYPE_ITEM;
    }
    @Override
    public RecyclerView.ViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
        if (viewType != TYPE_ITEM) {
            //inflate your layout and pass it to view holder
            return new ViewHeader(mHeaderViews.get(viewType));
        }
        ...
    }
    @Override
    public void onBindViewHolder(RecyclerView.ViewHolder holder, int basePosition1) {
        if (holder instanceof ViewHeader) {
            return;
        }
        int basePosition = basePosition1 -  mHeaderViews.size();
        ...
    }
}

0

कुछ साल हो गए हैं, लेकिन अभी कोई भी इसे बाद में पढ़ रहा है ...

उपरोक्त कोड का उपयोग करके, केवल हेडर लेआउट प्रदर्शित किया जाता है क्योंकि व्यू टाइप हमेशा 0 होता है।

समस्या निरंतर घोषणा में है:

private static final int HEADER = 0;
private static final int OTHER = 0;  <== bug 

यदि आप उन दोनों को शून्य घोषित करते हैं, तो आपको हमेशा शून्य मिलेगा!


0

मैंने EC84B4 द्वारा प्रस्तावित वही दृष्टिकोण लागू किया है उत्तर , लेकिन मैंने RecycleViewAdapter को अमूर्त किया है और इंटरफेस के माध्यम से इसे आसानी से फिर से उपयोग करने योग्य बनाता हूं।

तो मेरे दृष्टिकोण का उपयोग करने के लिए आपको अपनी परियोजना में निम्नलिखित आधार वर्गों और इंटरफेस को जोड़ना चाहिए:

1) इंटरफ़ेस जो एडाप्टर के लिए डेटा प्रदान करता है (सामान्य प्रकार टी का संग्रह, और अतिरिक्त पैरामीटर (यदि आवश्यक हो) जेनेरिक प्रकार पी)

public interface IRecycleViewListHolder<T,P>{
            P getAdapterParameters();
            T getItem(int position);
            int getSize();
    }

2) अपने आइटम (हेडर / आइटम) को बांधने के लिए कारखाना:

public interface IViewHolderBinderFactory<T,P> {
        void bindView(RecyclerView.ViewHolder holder, int position,IRecycleViewListHolder<T,P> dataHolder);
}

3) फैक्टरी के लिए व्यूहोल्डर्स (हेडर / आइटम):

public interface IViewHolderFactory {
    RecyclerView.ViewHolder provideInflatedViewHolder(int viewType, LayoutInflater layoutInflater,@NonNull ViewGroup parent);
}

4) हैडर के साथ एडाप्टर के लिए बेस क्लास:

public class RecycleViewHeaderBased<T,P> extends RecyclerView.Adapter<RecyclerView.ViewHolder>{

    public final static int HEADER_TYPE = 1;
    public final static int ITEM_TYPE = 0;
    private final IRecycleViewListHolder<T, P> dataHolder;
    private final IViewHolderBinderFactory<T,P> binderFactory;
    private final IViewHolderFactory viewHolderFactory;

    public RecycleViewHeaderBased(IRecycleViewListHolder<T,P> dataHolder, IViewHolderBinderFactory<T,P> binderFactory, IViewHolderFactory viewHolderFactory) {
        this.dataHolder = dataHolder;
        this.binderFactory = binderFactory;
        this.viewHolderFactory = viewHolderFactory;
    }

    @NonNull
    @Override
    public RecyclerView.ViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
        LayoutInflater layoutInflater = LayoutInflater.from(parent.getContext());
        return viewHolderFactory.provideInflatedViewHolder(viewType,layoutInflater,parent);
    }

    @Override
    public void onBindViewHolder(@NonNull RecyclerView.ViewHolder holder, int position) {
            binderFactory.bindView(holder, position,dataHolder);
    }

    @Override
    public int getItemViewType(int position) {
        if(position == 0)
            return HEADER_TYPE;
        return ITEM_TYPE;
    }

    @Override
    public int getItemCount() {
        return dataHolder.getSize()+1;
    }
}

उदाहरण का उपयोग करें :

1) IRecycleViewListHolder कार्यान्वयन:

public class AssetTaskListData implements IRecycleViewListHolder<Map.Entry<Integer, Integer>, GroupedRecord> {
    private List<Map.Entry<Integer, Integer>> assetCountList;
    private GroupedRecord record;

    public AssetTaskListData(Map<Integer, Integer> assetCountListSrc, GroupedRecord record) {
        this.assetCountList =  new ArrayList<>();
        for(Object  entry: assetCountListSrc.entrySet().toArray()){
            Map.Entry<Integer,Integer> entryTyped = (Map.Entry<Integer,Integer>)entry;
            assetCountList.add(entryTyped);
        }
        this.record = record;
    }

    @Override
    public GroupedRecord getAdapterParameters() {
        return record;
    }

    @Override
    public Map.Entry<Integer, Integer> getItem(int position) {
        return assetCountList.get(position-1);
    }

    @Override
    public int getSize() {
        return assetCountList.size();
    }
}

2) IVIVHolderBinder कार्यान्वयन:

public class AssetTaskListBinderFactory implements IViewHolderBinderFactory<Map.Entry<Integer, Integer>, GroupedRecord> {
    @Override
    public void bindView(RecyclerView.ViewHolder holder, int position, IRecycleViewListHolder<Map.Entry<Integer, Integer>, GroupedRecord> dataHolder) {
        if (holder instanceof AssetItemViewHolder) {
            Integer assetId = dataHolder.getItem(position).getKey();
            Integer assetCount = dataHolder.getItem(position).getValue();
            ((AssetItemViewHolder) holder).bindItem(dataHolder.getAdapterParameters().getRecordId(), assetId, assetCount);
        } else {
            ((AssetHeaderViewHolder) holder).bindItem(dataHolder.getAdapterParameters());
        }
    }
}

3) IViewHolderFactory कार्यान्वयन:

public class AssetTaskListViewHolderFactory implements IViewHolderFactory {
    private IPropertyTypeIconMapper iconMapper;
    private ITypeCaster caster;

    public AssetTaskListViewHolderFactory(IPropertyTypeIconMapper iconMapper, ITypeCaster caster) {
        this.iconMapper = iconMapper;
        this.caster = caster;
    }

    @Override
    public RecyclerView.ViewHolder provideInflatedViewHolder(int viewType, LayoutInflater layoutInflater, @NonNull ViewGroup parent) {
        if (viewType == RecycleViewHeaderBased.HEADER_TYPE) {
            AssetBasedHeaderItemBinding item = DataBindingUtil.inflate(layoutInflater, R.layout.asset_based_header_item, parent, false);
            return new AssetHeaderViewHolder(item.getRoot(), item, caster);
        }
        AssetBasedListItemBinding item = DataBindingUtil.inflate(layoutInflater, R.layout.asset_based_list_item, parent, false);
        return new AssetItemViewHolder(item.getRoot(), item, iconMapper, parent.getContext());
    }
}

4) व्युत्पन्न अनुकूलक

public class AssetHeaderTaskListAdapter extends RecycleViewHeaderBased<Map.Entry<Integer, Integer>, GroupedRecord> {
   public AssetHeaderTaskListAdapter(IRecycleViewListHolder<Map.Entry<Integer, Integer>, GroupedRecord> dataHolder,
                                      IViewHolderBinderFactory binderFactory,
                                      IViewHolderFactory viewHolderFactory) {
        super(dataHolder, binderFactory, viewHolderFactory);
    }
}

5) तत्काल एडाप्टर वर्ग:

private void setUpAdapter() {
        Map<Integer, Integer> objectTypesCountForGroupedTask = groupedTaskRepository.getObjectTypesCountForGroupedTask(this.groupedRecordId);
        AssetTaskListData assetTaskListData = new AssetTaskListData(objectTypesCountForGroupedTask, getGroupedRecord());
        adapter = new AssetHeaderTaskListAdapter(assetTaskListData,new AssetTaskListBinderFactory(),new AssetTaskListViewHolderFactory(iconMapper,caster));
        assetTaskListRecycler.setAdapter(adapter);
    }

पुनश्च : AssetItemViewHolder, AssetBasedListItemBinding, आदि मेरे आवेदन अपने स्वयं के प्रयोजनों के लिए अपने स्वयं के द्वारा अदला-बदली होनी चाहिए।

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