Fixed bug when detecting clicks on sticky headers

Rafael Dominiquini · Rafael Dominiquini · commit 387c24b8b943 · 2016-04-18T14:07:08.000-03:00
diff --git a/build.gradle b/build.gradle
@@ -24,6 +24,6 @@ ext {
     supportLibsVersion = '23.3.0'
     targetSdkVersion = 23
     minSdkVersion = 11
-    versionCode = 16
-    versionName = "0.5.6"
+    versionCode = 18
+    versionName = "0.5.8"
 }
diff --git a/library/src/main/java/com/timehop/stickyheadersrecyclerview/HeaderPositionCalculator.java b/library/src/main/java/com/timehop/stickyheadersrecyclerview/HeaderPositionCalculator.java
@@ -21,13 +21,6 @@ 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;
     mHeaderProvider = headerProvider;
@@ -49,15 +42,15 @@ public HeaderPositionCalculator(StickyRecyclerHeadersAdapter adapter, HeaderProv
   public boolean hasStickyHeader(View itemView, int orientation, int position) {
     int offset, margin;
 
-    mDimensionCalculator.initMargins(mTempRect1, itemView);
-
     if (itemView != null) {
+      Rect rect = mDimensionCalculator.getMargins(itemView);
+
       if (orientation == LinearLayout.VERTICAL) {
         offset = itemView.getTop();
-        margin = mTempRect1.top;
+        margin = rect.top;
       } else {
         offset = itemView.getLeft();
-        margin = mTempRect1.left;
+        margin = rect.left;
       }
     } else {
       offset = -1;
@@ -127,30 +120,25 @@ public boolean headerObscuringSomeItem(RecyclerView parent, View firstHeader) {
     return false;
   }
 
-  public void initHeaderBounds(Rect bounds, RecyclerView recyclerView, View header, View firstView, boolean firstHeader, boolean enableStickyHeader) {
+  public Rect getHeaderBounds(RecyclerView recyclerView, View header, View firstView, boolean firstHeader, boolean enableStickyHeader) {
     int orientation = mOrientationProvider.getOrientation(recyclerView);
-    initDefaultHeaderOffset(bounds, recyclerView, header, firstView, orientation, enableStickyHeader);
+
+    Rect bounds = getDefaultHeaderOffset(recyclerView, header, firstView, orientation, enableStickyHeader);
 
     if (enableStickyHeader && 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);
     }
-  }
-
-  public Rect getHeaderBounds(RecyclerView recyclerView, View header, View firstView, boolean firstHeader, boolean enableStickyHeader) {
-    Rect rect = new Rect();
-
-    initHeaderBounds(rect, recyclerView, header, firstView, firstHeader, enableStickyHeader);
 
-    return rect;
+    return bounds;
   }
 
-  private void initDefaultHeaderOffset(Rect headerMargins, RecyclerView recyclerView, View header, View firstView, int orientation, boolean enableStickyHeader) {
+  private Rect getDefaultHeaderOffset(RecyclerView recyclerView, View header, View firstView, int orientation, boolean enableStickyHeader) {
     int translationX, translationY;
 
-    mDimensionCalculator.initMargins(mTempRect1, header);
+    Rect headerMargins = mDimensionCalculator.getMargins(header);
 
     if (header != null && firstView != null) {
       ViewGroup.LayoutParams layoutParams = firstView.getLayoutParams();
@@ -163,18 +151,20 @@ private void initDefaultHeaderOffset(Rect headerMargins, RecyclerView recyclerVi
       }
 
       if (orientation == LinearLayoutManager.VERTICAL) {
-        translationX = firstView.getLeft() - leftMargin + mTempRect1.left;
+        translationX = firstView.getLeft() - leftMargin + headerMargins.left;
         translationY = enableStickyHeader ?
-                Math.max(firstView.getTop() - topMargin - header.getHeight() - mTempRect1.bottom, getListTop(recyclerView) + mTempRect1.top) :
-                firstView.getTop() - topMargin - header.getHeight() - mTempRect1.bottom;
+                Math.max(firstView.getTop() - topMargin - header.getHeight() - headerMargins.bottom, getListTop(recyclerView) + headerMargins.top) :
+                firstView.getTop() - topMargin - header.getHeight() - headerMargins.bottom;
       } else {
-        translationY = firstView.getTop() - topMargin + mTempRect1.top;
+        translationY = firstView.getTop() - topMargin + headerMargins.top;
         translationX = enableStickyHeader ?
-                Math.max(firstView.getLeft() - leftMargin - header.getWidth() - mTempRect1.right, getListLeft(recyclerView) + mTempRect1.left) :
-                firstView.getLeft() - leftMargin - header.getWidth() - mTempRect1.right;
+                Math.max(firstView.getLeft() - leftMargin - header.getWidth() - headerMargins.right, getListLeft(recyclerView) + headerMargins.left) :
+                firstView.getLeft() - leftMargin - header.getWidth() - headerMargins.right;
       }
 
-      headerMargins.set(translationX, translationY, translationX + header.getWidth(), translationY + header.getHeight());
+      return new Rect(translationX, translationY, translationX + header.getWidth(), translationY + header.getHeight());
+    } else {
+      return headerMargins;
     }
   }
 
@@ -189,18 +179,18 @@ private boolean isStickyHeaderBeingPushedOffscreen(RecyclerView recyclerView, Vi
       boolean isReverseLayout = mOrientationProvider.isReverseLayout(recyclerView);
       if (firstViewUnderHeaderPosition > 0 && hasNewHeader(firstViewUnderHeaderPosition, isReverseLayout)) {
         View nextHeader = mHeaderProvider.getHeader(recyclerView, firstViewUnderHeaderPosition);
-        mDimensionCalculator.initMargins(mTempRect1, nextHeader);
-        mDimensionCalculator.initMargins(mTempRect2, stickyHeader);
+        Rect nextHeaderMargins = mDimensionCalculator.getMargins(nextHeader);
+        Rect headerMargins = mDimensionCalculator.getMargins(stickyHeader);
 
         if (mOrientationProvider.getOrientation(recyclerView) == LinearLayoutManager.VERTICAL) {
-          int topOfNextHeader = viewAfterHeader.getTop() - mTempRect1.bottom - nextHeader.getHeight() - mTempRect1.top;
-          int bottomOfThisHeader = recyclerView.getPaddingTop() + stickyHeader.getBottom() + mTempRect2.top + mTempRect2.bottom;
+          int topOfNextHeader = viewAfterHeader.getTop() - nextHeaderMargins.bottom - nextHeader.getHeight() - nextHeaderMargins.top;
+          int bottomOfThisHeader = recyclerView.getPaddingTop() + stickyHeader.getBottom() + headerMargins.top + headerMargins.bottom;
           if (topOfNextHeader < bottomOfThisHeader) {
             return true;
           }
         } else {
-          int leftOfNextHeader = viewAfterHeader.getLeft() - mTempRect1.right - nextHeader.getWidth() - mTempRect1.left;
-          int rightOfThisHeader = recyclerView.getPaddingLeft() + stickyHeader.getRight() + mTempRect2.left + mTempRect2.right;
+          int leftOfNextHeader = viewAfterHeader.getLeft() - nextHeaderMargins.right - nextHeader.getWidth() - nextHeaderMargins.left;
+          int rightOfThisHeader = recyclerView.getPaddingLeft() + stickyHeader.getRight() + headerMargins.left + headerMargins.right;
           if (leftOfNextHeader < rightOfThisHeader) {
             return true;
           }
@@ -214,18 +204,18 @@ private boolean isStickyHeaderBeingPushedOffscreen(RecyclerView recyclerView, Vi
   private void translateHeaderWithNextHeader(RecyclerView recyclerView, int orientation, Rect translation,
     View currentHeader, View viewAfterNextHeader, View nextHeader) {
 
-    mDimensionCalculator.initMargins(mTempRect1, nextHeader);
-    mDimensionCalculator.initMargins(mTempRect2, currentHeader);
+    Rect nextHeaderMargins = mDimensionCalculator.getMargins(nextHeader);
+    Rect stickyHeaderMargins = mDimensionCalculator.getMargins(currentHeader);
 
     if (orientation == LinearLayoutManager.VERTICAL) {
-      int topOfStickyHeader = getListTop(recyclerView) + mTempRect2.top + mTempRect2.bottom;
-      int shiftFromNextHeader = viewAfterNextHeader.getTop() - nextHeader.getHeight() - mTempRect1.bottom - mTempRect1.top - currentHeader.getHeight() - topOfStickyHeader;
+      int topOfStickyHeader = getListTop(recyclerView) + stickyHeaderMargins.top + stickyHeaderMargins.bottom;
+      int shiftFromNextHeader = viewAfterNextHeader.getTop() - nextHeader.getHeight() - nextHeaderMargins.bottom - nextHeaderMargins.top - currentHeader.getHeight() - topOfStickyHeader;
       if (shiftFromNextHeader < topOfStickyHeader) {
         translation.top += shiftFromNextHeader;
       }
     } else {
-      int leftOfStickyHeader = getListLeft(recyclerView) + mTempRect2.left + mTempRect2.right;
-      int shiftFromNextHeader = viewAfterNextHeader.getLeft() - nextHeader.getWidth() - mTempRect1.right - mTempRect1.left - currentHeader.getWidth() - leftOfStickyHeader;
+      int leftOfStickyHeader = getListLeft(recyclerView) + stickyHeaderMargins.left + stickyHeaderMargins.right;
+      int shiftFromNextHeader = viewAfterNextHeader.getLeft() - nextHeader.getWidth() - nextHeaderMargins.right - nextHeaderMargins.left - currentHeader.getWidth() - leftOfStickyHeader;
       if (shiftFromNextHeader < leftOfStickyHeader) {
         translation.left += shiftFromNextHeader;
       }
@@ -263,7 +253,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();
-    mDimensionCalculator.initMargins(mTempRect1, header);
+    Rect rect = mDimensionCalculator.getMargins(header);
 
     int adapterPosition = parent.getChildAdapterPosition(item);
     if (adapterPosition == RecyclerView.NO_POSITION || mHeaderProvider.getHeader(parent, adapterPosition) != header) {
@@ -274,13 +264,13 @@ private boolean itemIsObscuredByHeader(RecyclerView parent, View item, View head
 
     if (orientation == LinearLayoutManager.VERTICAL) {
       int itemTop = item.getTop() - layoutParams.topMargin;
-      int headerBottom = getListTop(parent) + header.getBottom() + mTempRect1.bottom + mTempRect1.top;
+      int headerBottom = getListTop(parent) + header.getBottom() + rect.bottom + rect.top;
       if (itemTop >= headerBottom) {
         return false;
       }
     } else {
       int itemLeft = item.getLeft() - layoutParams.leftMargin;
-      int headerRight = getListLeft(parent) + header.getRight() + mTempRect1.right + mTempRect1.left;
+      int headerRight = getListLeft(parent) + header.getRight() + rect.right + rect.left;
       if (itemLeft >= headerRight) {
         return false;
       }
diff --git a/library/src/main/java/com/timehop/stickyheadersrecyclerview/calculation/DimensionCalculator.java b/library/src/main/java/com/timehop/stickyheadersrecyclerview/calculation/DimensionCalculator.java
@@ -11,21 +11,63 @@
  */
 public class DimensionCalculator {
 
+  /**
+   * Returns {@link Rect} representing margins for any view.
+   *
+   * @param view for which to get margins
+   * @return margins for the given view. All 0 if the view does not support margins
+   */
+  public Rect getMargins(View view) {
+    LayoutParams layoutParams = view != null ? view.getLayoutParams() : null;
+
+    if (layoutParams != null && layoutParams instanceof MarginLayoutParams) {
+      return getMarginRect((MarginLayoutParams) layoutParams);
+    } else {
+      return new Rect();
+    }
+  }
+
   /**
    * Populates {@link Rect} with margins for any view.
    *
    *
    * @param margins rect to populate
    * @param view for which to get margins
    */
-  public void initMargins(Rect margins, View view) {
+  public Rect initMargins(Rect margins, View view) {
+    if (margins == null) {
+      margins = new Rect();
+    }
+
     LayoutParams layoutParams = view != null ? view.getLayoutParams() : null;
 
     if (layoutParams != null && layoutParams instanceof MarginLayoutParams) {
       initMarginRect(margins, (MarginLayoutParams) layoutParams);
     } else {
       margins.set(0, 0, 0, 0);
     }
+
+    return margins;
+  }
+
+  /**
+   * Converts {@link MarginLayoutParams} into a representative {@link Rect}
+   *
+   * @param marginLayoutParams margins to convert to a Rect
+   * @return Rect representing margins, where {@link MarginLayoutParams#leftMargin} is equivalent to
+   * {@link Rect#left}, etc.
+   */
+  private Rect getMarginRect(MarginLayoutParams marginLayoutParams) {
+    if (marginLayoutParams != null) {
+      return new Rect(
+              marginLayoutParams.leftMargin,
+              marginLayoutParams.topMargin,
+              marginLayoutParams.rightMargin,
+              marginLayoutParams.bottomMargin
+      );
+    } else {
+      return new Rect();
+    }
   }
 
   /**
@@ -35,7 +77,11 @@ public void initMargins(Rect margins, View view) {
    * {@link MarginLayoutParams#leftMargin} is equivalent to {@link Rect#left}, etc.
    * @param marginLayoutParams margins to populate the Rect with
    */
-  private void initMarginRect(Rect marginRect, MarginLayoutParams marginLayoutParams) {
+  private Rect initMarginRect(Rect marginRect, MarginLayoutParams marginLayoutParams) {
+    if (marginRect == null) {
+      marginRect = new Rect();
+    }
+
     if (marginLayoutParams != null) {
       marginRect.set(
               marginLayoutParams.leftMargin,
@@ -44,17 +90,7 @@ private void initMarginRect(Rect marginRect, MarginLayoutParams marginLayoutPara
               marginLayoutParams.bottomMargin
       );
     }
-  }
-
-  public Rect getMarginRect(View header) {
-    Rect rect = new Rect();
-
-    if (header != null && header.getLayoutParams() instanceof MarginLayoutParams) {
-      initMarginRect(rect, (MarginLayoutParams) header.getLayoutParams());
-    } else {
-      rect.set(0, 0, 0, 0);
-    }
 
-    return rect;
+    return marginRect;
   }
 }
diff --git a/library/src/main/java/com/timehop/stickyheadersrecyclerview/decorators/StickyRecyclerHeadersDecoration.java b/library/src/main/java/com/timehop/stickyheadersrecyclerview/decorators/StickyRecyclerHeadersDecoration.java
@@ -31,12 +31,7 @@ public class StickyRecyclerHeadersDecoration extends RecyclerView.ItemDecoration
   private ItemVisibilityAdapter mVisibilityAdapter;
   private StickyRecyclerHeadersPositionChangeListener mHeaderListener;
 
-  /**
-   * 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 SparseArray<Rect> mHeaderRects = new SparseArray<>();
-  private final Rect mTempRect = new Rect();
 
   public StickyRecyclerHeadersDecoration(StickyRecyclerHeadersAdapter adapter) {
     this(adapter, new LayoutManagerOrientationProvider(), new DimensionCalculator(), true);
@@ -87,18 +82,20 @@ 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) {
-    mDimensionCalculator.initMargins(mTempRect, header);
+    Rect headerMargins = mDimensionCalculator.getMargins(header);
     if (orientation == LinearLayoutManager.VERTICAL) {
-      itemOffsets.top = header.getHeight() + mTempRect.top + mTempRect.bottom;
+      itemOffsets.top = header.getHeight() + headerMargins.top + headerMargins.bottom;
     } else {
-      itemOffsets.left = header.getWidth() + mTempRect.left + mTempRect.right;
+      itemOffsets.left = header.getWidth() + headerMargins.left + headerMargins.right;
     }
   }
 
   @Override
   public void onDrawOver(Canvas canvas, RecyclerView parent, RecyclerView.State state) {
     super.onDrawOver(canvas, parent, state);
 
+    mHeaderRects.clear();
+
     final int childCount = parent.getChildCount();
     if (childCount <= 0 || mAdapter.getItemCount() <= 0) {
       return;
@@ -117,15 +114,11 @@ public void onDrawOver(Canvas canvas, RecyclerView parent, RecyclerView.State st
         if (hasStickyHeader || hasNewHeader) {
           View header = mHeaderProvider.getHeader(parent, position);
 
-          //re-use existing Rect, if any.
-          Rect headerOffset = mHeaderRects.get(position);
-          if (headerOffset == null) {
-            mHeaderRects.put(position, headerOffset = new Rect());
-          }
-
-          mHeaderPositionCalculator.initHeaderBounds(headerOffset, parent, header, itemView, hasStickyHeader, mEnableStickyHeader);
+          Rect headerOffset = mHeaderPositionCalculator.getHeaderBounds(parent, header, itemView, hasStickyHeader, mEnableStickyHeader);
           mRenderer.drawHeader(parent, canvas, header, headerOffset);
 
+          mHeaderRects.put(position, headerOffset);
+
           if (mEnableStickyHeader && mHeaderListener != null) {
             mHeaderListener.onHeaderPositionChanged(this, mAdapter.getHeaderId(position), header, position, headerOffset);
           }
diff --git a/library/src/main/java/com/timehop/stickyheadersrecyclerview/rendering/HeaderRenderer.java b/library/src/main/java/com/timehop/stickyheadersrecyclerview/rendering/HeaderRenderer.java

Original file line number	Diff line number	Diff line change
`@@ -24,6 +24,6 @@ ext {`
`24`	`24`	`supportLibsVersion = '23.3.0'`
`25`	`25`	`targetSdkVersion = 23`
`26`	`26`	`minSdkVersion = 11`
`27`		`- versionCode = 16`
`28`		`- versionName = "0.5.6"`
	`27`	`+ versionCode = 18`
	`28`	`+ versionName = "0.5.8"`
`29`	`29`	`}`