Merge pull request timehop#72 from denisk20/perf-improvements

timehop#19: reducing the number of Rect allocations during list scrolling.

Author: jacobtabak

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;
@@ -86,9 +94,9 @@ private boolean indexOutOfBounds(int position) {
     return position < 0 || position >= mAdapter.getItemCount();
   }
 
-  public Rect getHeaderBounds(RecyclerView recyclerView, View header, View firstView, boolean firstHeader) {
+  public void initHeaderBounds(Rect bounds, RecyclerView recyclerView, View header, View firstView, boolean firstHeader) {
     int orientation = mOrientationProvider.getOrientation(recyclerView);
-    Rect bounds = getDefaultHeaderOffset(recyclerView, header, firstView, orientation);
+    initDefaultHeaderOffset(bounds, recyclerView, header, firstView, orientation);
 
     if (firstHeader && isStickyHeaderBeingPushedOffscreen(recyclerView, header)) {
       View viewAfterNextHeader = getFirstViewUnobscuredByHeader(recyclerView, header);
@@ -97,27 +105,25 @@ public Rect getHeaderBounds(RecyclerView recyclerView, View header, View firstVi
       translateHeaderWithNextHeader(recyclerView, mOrientationProvider.getOrientation(recyclerView), bounds,
           header, viewAfterNextHeader, secondHeader);
     }
-
-    return bounds;
   }
 
-  private Rect getDefaultHeaderOffset(RecyclerView recyclerView, View header, View firstView, int orientation) {
+  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(),
-        translationY + header.getHeight());
+    headerMargins.set(translationX, translationY, translationX + header.getWidth(),
+            translationY + header.getHeight());
   }
 
   private boolean isStickyHeaderBeingPushedOffscreen(RecyclerView recyclerView, View stickyHeader) {
@@ -130,18 +136,18 @@ private boolean isStickyHeaderBeingPushedOffscreen(RecyclerView recyclerView, Vi
     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;
         }
@@ -152,18 +158,18 @@ 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);
+    View currentHeader, View viewAfterNextHeader, View nextHeader) {
+    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;
       }
@@ -201,7 +207,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) {
@@ -212,13 +218,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

@@ -24,6 +24,12 @@ public class StickyRecyclerHeadersDecoration extends RecyclerView.ItemDecoration
   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();
+
   // TODO: Consider passing in orientation to simplify orientation accounting within calculation
   public StickyRecyclerHeadersDecoration(StickyRecyclerHeadersAdapter adapter) {
     this(adapter, new LinearLayoutOrientationProvider(), new DimensionCalculator());
@@ -74,24 +80,24 @@ 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) {
@@ -101,9 +107,14 @@ public void onDrawOver(Canvas canvas, RecyclerView parent, RecyclerView.State st
       boolean hasStickyHeader = mHeaderPositionCalculator.hasStickyHeader(itemView, mOrientationProvider.getOrientation(parent), 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);
       }
     }
   }

library/src/main/java/com/timehop/stickyheadersrecyclerview/calculation/DimensionCalculator.java

@@ -12,31 +12,32 @@
 public class DimensionCalculator {
 
   /**
-   * Returns {@link Rect} representing margins for any view.
+   * Populates {@link Rect} with margins for any view.
    *
+   *
+   * @param margins rect to populate
    * @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) {
+  public void initMargins(Rect margins, View view) {
     LayoutParams layoutParams = view.getLayoutParams();
 
     if (layoutParams instanceof MarginLayoutParams) {
       MarginLayoutParams marginLayoutParams = (MarginLayoutParams) layoutParams;
-      return getMarginRect(marginLayoutParams);
+      initMarginRect(margins, marginLayoutParams);
     } else {
-      return new Rect();
+        margins.set(0, 0, 0, 0);
     }
   }
 
   /**
-   * Converts {@link MarginLayoutParams} into a representative {@link Rect}
+   * 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.
+   * @param marginRect Rect to be initialized with margins coordinates, where
+   * {@link MarginLayoutParams#leftMargin} is equivalent to {@link Rect#left}, etc.
+   * @param marginLayoutParams margins to populate the Rect with
    */
-  private Rect getMarginRect(MarginLayoutParams marginLayoutParams) {
-    return new Rect(
+  private void initMarginRect(Rect marginRect, MarginLayoutParams marginLayoutParams) {
+      marginRect.set(
         marginLayoutParams.leftMargin,
         marginLayoutParams.topMargin,
         marginLayoutParams.rightMargin,

library/src/main/java/com/timehop/stickyheadersrecyclerview/rendering/HeaderRenderer.java

@@ -17,6 +17,12 @@ public class HeaderRenderer {
   private final DimensionCalculator mDimensionCalculator;
   private final OrientationProvider mOrientationProvider;
 
+  /**
+   * 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();
+
   public HeaderRenderer(OrientationProvider orientationProvider) {
     this(orientationProvider, new DimensionCalculator());
   }
@@ -41,8 +47,8 @@ public void drawHeader(RecyclerView recyclerView, Canvas canvas, View header, Re
 
     if (recyclerView.getLayoutManager().getClipToPadding()) {
       // Clip drawing of headers to the padding of the RecyclerView. Avoids drawing in the padding
-      Rect clipRect = getClipRectForHeader(recyclerView, header);
-      canvas.clipRect(clipRect);
+      initClipRectForHeader(mTempRect, recyclerView, header);
+      canvas.clipRect(mTempRect);
     }
 
     canvas.translate(offset.left, offset.top);
@@ -52,30 +58,30 @@ public void drawHeader(RecyclerView recyclerView, Canvas canvas, View header, Re
   }
 
   /**
-   * Gets a clipping rect for the header based on the margins of the header and the padding of the
+   * Initializes a clipping rect for the header based on the margins of the header and the padding of the
    * recycler.
    * FIXME: Currently right margin in VERTICAL orientation and bottom margin in HORIZONTAL
    * orientation are clipped so they look accurate, but the headers are not being drawn at the
    * correctly smaller width and height respectively.
    *
+   * @param clipRect {@link Rect} for clipping a provided header to the padding of a recycler view
    * @param recyclerView for which to provide a header
    * @param header       for clipping
-   * @return a {@link Rect} for clipping a provided header to the padding of a recycler view
    */
-  private Rect getClipRectForHeader(RecyclerView recyclerView, View header) {
-    Rect headerMargins = mDimensionCalculator.getMargins(header);
+  private void initClipRectForHeader(Rect clipRect, RecyclerView recyclerView, View header) {
+    mDimensionCalculator.initMargins(clipRect, header);
     if (mOrientationProvider.getOrientation(recyclerView) == LinearLayout.VERTICAL) {
-      return new Rect(
+      clipRect.set(
           recyclerView.getPaddingLeft(),
           recyclerView.getPaddingTop(),
-          recyclerView.getWidth() - recyclerView.getPaddingRight() - headerMargins.right,
+          recyclerView.getWidth() - recyclerView.getPaddingRight() - clipRect.right,
           recyclerView.getHeight() - recyclerView.getPaddingBottom());
     } else {
-      return new Rect(
+        clipRect.set(
           recyclerView.getPaddingLeft(),
           recyclerView.getPaddingTop(),
           recyclerView.getWidth() - recyclerView.getPaddingRight(),
-          recyclerView.getHeight() - recyclerView.getPaddingBottom() - headerMargins.bottom);
+          recyclerView.getHeight() - recyclerView.getPaddingBottom() - clipRect.bottom);
     }
   }