Merge branch 'master' of https://github.com/timehop/sticky-headers-recyclerview

Author: Dominiquini

README.md

@@ -16,7 +16,7 @@ Here is a quick video of it in action (click to see the full video):
 Download
 --------
 
-    compile 'com.github.smartcanvas:sticky-headers-recyclerview:0.5'
+    compile 'com.github.smartcanvas:sticky-headers-recyclerview:0.5.0'
 
 Usage
 -----
@@ -94,10 +94,14 @@ Known Issues
 
 * I haven't tested this with ItemAnimators yet.
 
+* The header views are drawn to a canvas, and are not actually a part of the view hierarchy. As such, they can't have touch states, and you may run into issues if you try to load images into them asynchronously.
+
 Version History
 ---------------
 0.5 (8/20/2015) - Added position change listener
 
+0.4.2 (8/21/2015) - Add support for reverse `ReverseLayout` in `LinearLayoutManager` by [AntonPukhonin](https://github.com/AntonPukhonin)
+
 0.4.1 (6/24/2015) - Fix "dancing headers" by DarkJaguar91
 
 0.4.0 (4/16/2015) - Code reorganization by danoz73, fixes for different sized headers, performance improvements

build.gradle

@@ -24,5 +24,5 @@ ext {
     targetSdkVersion = 22
     minSdkVersion = 14
     versionCode = 12
-    versionName = "0.5"
+    versionName = "0.5.0"
 }

gradle.properties

@@ -17,8 +17,8 @@
 # http://www.gradle.org/docs/current/userguide/multi_project_builds.html#sec:decoupled_projects
 # org.gradle.parallel=true
 
-VERSION_NAME=0.4.1
-VERSION_CODE=11
+VERSION_NAME=0.4.2
+VERSION_CODE=12
 GROUP=com.timehop.stickyheadersrecyclerview
 
 POM_DESCRIPTION=RecyclerView decorator for sticky list headers.

library/src/main/java/com/timehop/stickyheadersrecyclerview/HeaderPositionCalculator.java

@@ -20,6 +20,13 @@ public class HeaderPositionCalculator {
     private final HeaderProvider mHeaderProvider;
     private final DimensionCalculator mDimensionCalculator;
 
+    /**
+     * The following fields are used as buffers for internal calculations. Their sole purpose is to avoid
+     * allocating new Rect every time we need one.
+     */
+    private final Rect mTempRect1 = new Rect();
+    private final Rect mTempRect2 = new Rect();
+
     public HeaderPositionCalculator(StickyRecyclerHeadersAdapter adapter, HeaderProvider headerProvider,
                                     OrientationProvider orientationProvider, DimensionCalculator dimensionCalculator) {
         mAdapter = adapter;
@@ -41,12 +48,13 @@ public HeaderPositionCalculator(StickyRecyclerHeadersAdapter adapter, HeaderProv
      */
     public boolean hasStickyHeader(View itemView, int orientation, int position) {
         int offset, margin;
+        mDimensionCalculator.initMargins(mTempRect1, itemView);
         if (orientation == LinearLayout.VERTICAL) {
             offset = itemView.getTop();
-            margin = mDimensionCalculator.getMargins(itemView).top;
+            margin = mTempRect1.top;
         } else {
             offset = itemView.getLeft();
-            margin = mDimensionCalculator.getMargins(itemView).left;
+            margin = mTempRect1.left;
         }
 
         return offset <= margin && mAdapter.getHeaderId(position) >= 0;
@@ -56,11 +64,12 @@ public boolean hasStickyHeader(View itemView, int orientation, int position) {
      * Determines if an item in the list should have a header that is different than the item in the
      * list that immediately precedes it. Items with no headers will always return false.
      *
-     * @param position of the list item in questions
+     * @param position        of the list item in questions
+     * @param isReverseLayout TRUE if layout manager has flag isReverseLayout
      * @return true if this item has a different header than the previous item in the list
      * @see {@link StickyRecyclerHeadersAdapter#getHeaderId(int)}
      */
-    public boolean hasNewHeader(int position) {
+    public boolean hasNewHeader(int position, boolean isReverseLayout) {
         if (indexOutOfBounds(position)) {
             return false;
         }
@@ -71,28 +80,20 @@ public boolean hasNewHeader(int position) {
             return false;
         }
 
-        return position == 0 || headerId != mAdapter.getHeaderId(position - 1);
+        long nextItemHeaderId = -1;
+        int nextItemPosition = position + (isReverseLayout ? 1 : -1);
+        if (!indexOutOfBounds(nextItemPosition)) {
+            nextItemHeaderId = mAdapter.getHeaderId(nextItemPosition);
+        }
+        int firstItemPosition = isReverseLayout ? mAdapter.getItemCount() - 1 : 0;
+
+        return position == firstItemPosition || headerId != nextItemHeaderId;
     }
 
     private boolean indexOutOfBounds(int position) {
         return position < 0 || position >= mAdapter.getItemCount();
     }
 
-    public Rect getHeaderBounds(RecyclerView recyclerView, View header, View firstView, boolean firstHeader) {
-        int orientation = mOrientationProvider.getOrientation(recyclerView);
-        Rect bounds = getDefaultHeaderOffset(recyclerView, header, firstView, orientation);
-
-        if (firstHeader && isStickyHeaderBeingPushedOffscreen(recyclerView, header)) {
-            View viewAfterNextHeader = getFirstViewUnobscuredByHeader(recyclerView, header);
-            int firstViewUnderHeaderPosition = recyclerView.getChildAdapterPosition(viewAfterNextHeader);
-            View secondHeader = mHeaderProvider.getHeader(recyclerView, firstViewUnderHeaderPosition);
-            translateHeaderWithNextHeader(recyclerView, mOrientationProvider.getOrientation(recyclerView), bounds,
-                    header, viewAfterNextHeader, secondHeader);
-        }
-
-        return bounds;
-    }
-
     /**
      * Verify if header obscure some item on RecyclerView
      *
@@ -109,22 +110,35 @@ public boolean headerObscuringSomeItem(RecyclerView parent, View firstHeader) {
         return false;
     }
 
-    private Rect getDefaultHeaderOffset(RecyclerView recyclerView, View header, View firstView, int orientation) {
+    public void initHeaderBounds(Rect bounds, RecyclerView recyclerView, View header, View firstView, boolean firstHeader) {
+        int orientation = mOrientationProvider.getOrientation(recyclerView);
+        initDefaultHeaderOffset(bounds, recyclerView, header, firstView, orientation);
+
+        if (firstHeader && isStickyHeaderBeingPushedOffscreen(recyclerView, header)) {
+            View viewAfterNextHeader = getFirstViewUnobscuredByHeader(recyclerView, header);
+            int firstViewUnderHeaderPosition = recyclerView.getChildAdapterPosition(viewAfterNextHeader);
+            View secondHeader = mHeaderProvider.getHeader(recyclerView, firstViewUnderHeaderPosition);
+            translateHeaderWithNextHeader(recyclerView, mOrientationProvider.getOrientation(recyclerView), bounds,
+                    header, viewAfterNextHeader, secondHeader);
+        }
+    }
+
+    private void initDefaultHeaderOffset(Rect headerMargins, RecyclerView recyclerView, View header, View firstView, int orientation) {
         int translationX, translationY;
-        Rect headerMargins = mDimensionCalculator.getMargins(header);
+        mDimensionCalculator.initMargins(mTempRect1, header);
         if (orientation == LinearLayoutManager.VERTICAL) {
-            translationX = firstView.getLeft() + headerMargins.left;
+            translationX = firstView.getLeft() + mTempRect1.left;
             translationY = Math.max(
-                    firstView.getTop() - header.getHeight() - headerMargins.bottom,
-                    getListTop(recyclerView) + headerMargins.top);
+                    firstView.getTop() - header.getHeight() - mTempRect1.bottom,
+                    getListTop(recyclerView) + mTempRect1.top);
         } else {
-            translationY = firstView.getTop() + headerMargins.top;
+            translationY = firstView.getTop() + mTempRect1.top;
             translationX = Math.max(
-                    firstView.getLeft() - header.getWidth() - headerMargins.right,
-                    getListLeft(recyclerView) + headerMargins.left);
+                    firstView.getLeft() - header.getWidth() - mTempRect1.right,
+                    getListLeft(recyclerView) + mTempRect1.left);
         }
 
-        return new Rect(translationX, translationY, translationX + header.getWidth(),
+        headerMargins.set(translationX, translationY, translationX + header.getWidth(),
                 translationY + header.getHeight());
     }
 
@@ -135,20 +149,21 @@ private boolean isStickyHeaderBeingPushedOffscreen(RecyclerView recyclerView, Vi
             return false;
         }
 
-        if (firstViewUnderHeaderPosition > 0 && hasNewHeader(firstViewUnderHeaderPosition)) {
+        boolean isReverseLayout = mOrientationProvider.isReverseLayout(recyclerView);
+        if (firstViewUnderHeaderPosition > 0 && hasNewHeader(firstViewUnderHeaderPosition, isReverseLayout)) {
             View nextHeader = mHeaderProvider.getHeader(recyclerView, firstViewUnderHeaderPosition);
-            Rect nextHeaderMargins = mDimensionCalculator.getMargins(nextHeader);
-            Rect headerMargins = mDimensionCalculator.getMargins(stickyHeader);
+            mDimensionCalculator.initMargins(mTempRect1, nextHeader);
+            mDimensionCalculator.initMargins(mTempRect2, stickyHeader);
 
             if (mOrientationProvider.getOrientation(recyclerView) == LinearLayoutManager.VERTICAL) {
-                int topOfNextHeader = viewAfterHeader.getTop() - nextHeaderMargins.bottom - nextHeader.getHeight() - nextHeaderMargins.top;
-                int bottomOfThisHeader = recyclerView.getPaddingTop() + stickyHeader.getBottom() + headerMargins.top + headerMargins.bottom;
+                int topOfNextHeader = viewAfterHeader.getTop() - mTempRect1.bottom - nextHeader.getHeight() - mTempRect1.top;
+                int bottomOfThisHeader = recyclerView.getPaddingTop() + stickyHeader.getBottom() + mTempRect2.top + mTempRect2.bottom;
                 if (topOfNextHeader < bottomOfThisHeader) {
                     return true;
                 }
             } else {
-                int leftOfNextHeader = viewAfterHeader.getLeft() - nextHeaderMargins.right - nextHeader.getWidth() - nextHeaderMargins.left;
-                int rightOfThisHeader = recyclerView.getPaddingLeft() + stickyHeader.getRight() + headerMargins.left + headerMargins.right;
+                int leftOfNextHeader = viewAfterHeader.getLeft() - mTempRect1.right - nextHeader.getWidth() - mTempRect1.left;
+                int rightOfThisHeader = recyclerView.getPaddingLeft() + stickyHeader.getRight() + mTempRect2.left + mTempRect2.right;
                 if (leftOfNextHeader < rightOfThisHeader) {
                     return true;
                 }
@@ -160,17 +175,17 @@ private boolean isStickyHeaderBeingPushedOffscreen(RecyclerView recyclerView, Vi
 
     private void translateHeaderWithNextHeader(RecyclerView recyclerView, int orientation, Rect translation,
                                                View currentHeader, View viewAfterNextHeader, View nextHeader) {
-        Rect nextHeaderMargins = mDimensionCalculator.getMargins(nextHeader);
-        Rect stickyHeaderMargins = mDimensionCalculator.getMargins(currentHeader);
+        mDimensionCalculator.initMargins(mTempRect1, nextHeader);
+        mDimensionCalculator.initMargins(mTempRect2, currentHeader);
         if (orientation == LinearLayoutManager.VERTICAL) {
-            int topOfStickyHeader = getListTop(recyclerView) + stickyHeaderMargins.top + stickyHeaderMargins.bottom;
-            int shiftFromNextHeader = viewAfterNextHeader.getTop() - nextHeader.getHeight() - nextHeaderMargins.bottom - nextHeaderMargins.top - currentHeader.getHeight() - topOfStickyHeader;
+            int topOfStickyHeader = getListTop(recyclerView) + mTempRect2.top + mTempRect2.bottom;
+            int shiftFromNextHeader = viewAfterNextHeader.getTop() - nextHeader.getHeight() - mTempRect1.bottom - mTempRect1.top - currentHeader.getHeight() - topOfStickyHeader;
             if (shiftFromNextHeader < topOfStickyHeader) {
                 translation.top += shiftFromNextHeader;
             }
         } else {
-            int leftOfStickyHeader = getListLeft(recyclerView) + stickyHeaderMargins.left + stickyHeaderMargins.right;
-            int shiftFromNextHeader = viewAfterNextHeader.getLeft() - nextHeader.getWidth() - nextHeaderMargins.right - nextHeaderMargins.left - currentHeader.getWidth() - leftOfStickyHeader;
+            int leftOfStickyHeader = getListLeft(recyclerView) + mTempRect2.left + mTempRect2.right;
+            int shiftFromNextHeader = viewAfterNextHeader.getLeft() - nextHeader.getWidth() - mTempRect1.right - mTempRect1.left - currentHeader.getWidth() - leftOfStickyHeader;
             if (shiftFromNextHeader < leftOfStickyHeader) {
                 translation.left += shiftFromNextHeader;
             }
@@ -180,11 +195,14 @@ private void translateHeaderWithNextHeader(RecyclerView recyclerView, int orient
     /**
      * Returns the first item currently in the RecyclerView that is not obscured by a header.
      *
-     * @param parent RecyclerView containing all the list items
+     * @param parent Recyclerview containing all the list items
      * @return first item that is fully beneath a header
      */
     private View getFirstViewUnobscuredByHeader(RecyclerView parent, View firstHeader) {
-        for (int i = 0; i < parent.getChildCount(); i++) {
+        boolean isReverseLayout = mOrientationProvider.isReverseLayout(parent);
+        int step = isReverseLayout ? -1 : 1;
+        int from = isReverseLayout ? parent.getChildCount() - 1 : 0;
+        for (int i = from; i >= 0 && i <= parent.getChildCount() - 1; i += step) {
             View child = parent.getChildAt(i);
             if (!itemIsObscuredByHeader(parent, child, firstHeader, mOrientationProvider.getOrientation(parent))) {
                 return child;
@@ -204,7 +222,7 @@ private View getFirstViewUnobscuredByHeader(RecyclerView parent, View firstHeade
      */
     private boolean itemIsObscuredByHeader(RecyclerView parent, View item, View header, int orientation) {
         RecyclerView.LayoutParams layoutParams = (RecyclerView.LayoutParams) item.getLayoutParams();
-        Rect headerMargins = mDimensionCalculator.getMargins(header);
+        mDimensionCalculator.initMargins(mTempRect1, header);
 
         int adapterPosition = parent.getChildAdapterPosition(item);
         if (adapterPosition == RecyclerView.NO_POSITION || mHeaderProvider.getHeader(parent, adapterPosition) != header) {
@@ -215,13 +233,13 @@ private boolean itemIsObscuredByHeader(RecyclerView parent, View item, View head
 
         if (orientation == LinearLayoutManager.VERTICAL) {
             int itemTop = item.getTop() - layoutParams.topMargin;
-            int headerBottom = header.getBottom() + headerMargins.bottom + headerMargins.top;
+            int headerBottom = header.getBottom() + mTempRect1.bottom + mTempRect1.top;
             if (itemTop >= headerBottom) {
                 return false;
             }
         } else {
             int itemLeft = item.getLeft() - layoutParams.leftMargin;
-            int headerRight = header.getRight() + headerMargins.right + headerMargins.left;
+            int headerRight = header.getRight() + mTempRect1.right + mTempRect1.left;
             if (itemLeft >= headerRight) {
                 return false;
             }

library/src/main/java/com/timehop/stickyheadersrecyclerview/StickyRecyclerHeadersDecoration.java

@@ -23,6 +23,11 @@ public class StickyRecyclerHeadersDecoration extends RecyclerView.ItemDecoration
     private final HeaderPositionCalculator mHeaderPositionCalculator;
     private final HeaderRenderer mRenderer;
     private final DimensionCalculator mDimensionCalculator;
+    /**
+     * The following field is used as a buffer for internal calculations. Its sole purpose is to avoid
+     * allocating new Rect every time we need one.
+     */
+    private final Rect mTempRect = new Rect();
     private StickyRecyclerHeadersPositionChangeListener mHeaderListener;
 
     // TODO: Consider passing in orientation to simplify orientation accounting within calculation
@@ -61,7 +66,7 @@ public void getItemOffsets(Rect outRect, View view, RecyclerView parent, Recycle
         if (itemPosition == RecyclerView.NO_POSITION) {
             return;
         }
-        if (mHeaderPositionCalculator.hasNewHeader(itemPosition)) {
+        if (mHeaderPositionCalculator.hasNewHeader(itemPosition, mOrientationProvider.isReverseLayout(parent))) {
             View header = getHeaderView(parent, itemPosition);
             setItemOffsetsForHeader(outRect, header, mOrientationProvider.getOrientation(parent));
         }
@@ -75,37 +80,41 @@ public void getItemOffsets(Rect outRect, View view, RecyclerView parent, Recycle
      * @param orientation used to calculate offset for the item
      */
     private void setItemOffsetsForHeader(Rect itemOffsets, View header, int orientation) {
-        Rect headerMargins = mDimensionCalculator.getMargins(header);
+        mDimensionCalculator.initMargins(mTempRect, header);
         if (orientation == LinearLayoutManager.VERTICAL) {
-            itemOffsets.top = header.getHeight() + headerMargins.top + headerMargins.bottom;
+            itemOffsets.top = header.getHeight() + mTempRect.top + mTempRect.bottom;
         } else {
-            itemOffsets.left = header.getWidth() + headerMargins.left + headerMargins.right;
+            itemOffsets.left = header.getWidth() + mTempRect.left + mTempRect.right;
         }
     }
 
     @Override
     public void onDrawOver(Canvas canvas, RecyclerView parent, RecyclerView.State state) {
         super.onDrawOver(canvas, parent, state);
-        mHeaderRects.clear();
 
-        if (parent.getChildCount() <= 0 || mAdapter.getItemCount() <= 0) {
+        final int childCount = parent.getChildCount();
+        if (childCount <= 0 || mAdapter.getItemCount() <= 0) {
             return;
         }
 
-        for (int i = 0; i < parent.getChildCount(); i++) {
+        for (int i = 0; i < childCount; i++) {
             View itemView = parent.getChildAt(i);
             int position = parent.getChildAdapterPosition(itemView);
             if (position == RecyclerView.NO_POSITION) {
                 continue;
             }
 
             boolean hasStickyHeader = mHeaderPositionCalculator.hasStickyHeader(itemView, mOrientationProvider.getOrientation(parent), position);
-            if (hasStickyHeader || mHeaderPositionCalculator.hasNewHeader(position)) {
+            if (hasStickyHeader || mHeaderPositionCalculator.hasNewHeader(position, mOrientationProvider.isReverseLayout(parent))) {
                 View header = mHeaderProvider.getHeader(parent, position);
-                Rect headerOffset = mHeaderPositionCalculator.getHeaderBounds(parent, header,
-                        itemView, hasStickyHeader);
+                //re-use existing Rect, if any.
+                Rect headerOffset = mHeaderRects.get(position);
+                if (headerOffset == null) {
+                    headerOffset = new Rect();
+                    mHeaderRects.put(position, headerOffset);
+                }
+                mHeaderPositionCalculator.initHeaderBounds(headerOffset, parent, header, itemView, hasStickyHeader);
                 mRenderer.drawHeader(parent, canvas, header, headerOffset);
-                mHeaderRects.put(position, headerOffset);
 
                 if (mHeaderListener != null) {
                     mHeaderListener.onHeaderPositionChanged(mAdapter.getHeaderId(position), header, position, headerOffset);

library/src/main/java/com/timehop/stickyheadersrecyclerview/StickyRecyclerHeadersTouchListener.java

@@ -35,7 +35,18 @@ public void setOnHeaderClickListener(OnHeaderClickListener listener) {
 
     @Override
     public boolean onInterceptTouchEvent(RecyclerView view, MotionEvent e) {
-        return mOnHeaderClickListener != null && mTapDetector.onTouchEvent(e);
+        if (this.mOnHeaderClickListener != null) {
+            boolean tapDetectorResponse = this.mTapDetector.onTouchEvent(e);
+            if (tapDetectorResponse) {
+                // Don't return false if a single tap is detected
+                return true;
+            }
+            if (e.getAction() == MotionEvent.ACTION_DOWN) {
+                int position = mDecor.findHeaderPositionUnder((int) e.getX(), (int) e.getY());
+                return position != -1;
+            }
+        }
+        return false;
     }
 
     @Override