docs: private void checkForGaps() {
          if (mLayoutManager == null) {
              return;
          }
  
          final VirtualLayoutManager layoutManager = mLayoutManager.get();
  
          if (layoutManager == null || layoutManager.getChildCount() == 0) {
              return;
          }
  
          final Range<Integer> range = getRange();
  
          // align position, which should check gap for
          final int minPos, maxPos, alignPos;
          if (layoutManager.getReverseLayout()) {
              minPos = layoutManager.findLastVisibleItemPosition();
              maxPos = layoutManager.findFirstVisibleItemPosition();
              alignPos = range.getUpper() - 1;
          } else {
              minPos = layoutManager.findFirstVisibleItemPosition();
              maxPos = layoutManager.findLastCompletelyVisibleItemPosition();
              alignPos = range.getLower();
          }
  
  
          final OrientationHelperEx orientationHelper = layoutManager.getMainOrientationHelper();
          final int childCount = layoutManager.getChildCount();
          int viewAnchor = Integer.MIN_VALUE;
          int alignLine = Integer.MIN_VALUE;
  
          // find view anchor and get align line, the views should be aligned to alignLine
          if (layoutManager.getReverseLayout()) {
              for (int i = childCount - 1; i >= 0; i--) {
                  View view = layoutManager.getChildAt(i);
                  int position = layoutManager.getPosition(view);
                  if (position == alignPos) {
                      viewAnchor = position;
                      if (i == childCount - 1) {
                          // if last child, alignLine is the end of child
                          alignLine = orientationHelper.getDecoratedEnd(view);
                      } else {
                          // if not, alignLine is the start of next child
                          View child = layoutManager.getChildAt(i + 1);
                          int aPos = layoutManager.getPosition(child);
                          if (aPos == position - 1) {
                              // if position is sequence, which means the next child is not hidden one
                              alignLine = orientationHelper.getDecoratedStart(child) - layoutManager.obtainExtraMargin(child, false)
                                      + layoutManager.obtainExtraMargin(view, true);
                          } else {
                              // if next child is hidden one, use end of current view
                              alignLine = orientationHelper.getDecoratedEnd(view);
                          }
                      }
                      break;
                  }
              }
          } else {
              for (int i = 0; i < childCount; i++) {
                  View view = layoutManager.getChildAt(i);
                  int position = layoutManager.getPosition(view);
                  if (position == alignPos) {
                      viewAnchor = position;
                      if (i == 0) {
                          // TODO: there is problem
                          // if first child, alignLine is the start
                          alignLine = orientationHelper.getDecoratedStart(view);
                      } else {
                          // if not, alignLine is the end of previous child
                          View child = layoutManager.getChildAt(i - 1);
                          alignLine = orientationHelper.getDecoratedEnd(child) + layoutManager.obtainExtraMargin(child, true, false)
                                  - layoutManager.obtainExtraMargin(view, false, false);
                          int viewStart = orientationHelper.getDecoratedStart(view);
                          if (alignLine == viewStart) {
                              //actually not gap here skip;
                              viewAnchor = Integer.MIN_VALUE;
                          } else {
                              int nextPosition = layoutManager.getPosition(child);
                              if (nextPosition != alignPos - 1) {
                                  //may has sticky layout, add extra space occur by stickyLayoutHelper
                                  LayoutHelper layoutHelper = layoutManager.findLayoutHelperByPosition(alignPos - 1);
                                  if (layoutHelper != null && layoutHelper instanceof StickyLayoutHelper) {
                                      if (layoutHelper.getFixedView() != null) {
                                          alignLine += layoutHelper.getFixedView().getMeasuredHeight();
                                      }
                                  }
                              } else {
                                  LayoutHelper layoutHelper = layoutManager.findLayoutHelperByPosition(nextPosition);
                                  layoutHelper.getRange();
                              }
                          }
                      }
                      break;
                  }
              }
          }
  
          if (viewAnchor == Integer.MIN_VALUE) {
              // if not find view anchor, break
              return;
          }
  
          View gapView = hasGapsToFix(layoutManager, viewAnchor, alignLine);
          if (gapView != null) {
              //FIXME do not clear loopup, may cause lane error while scroll
              //mLazySpanLookup.clear();
  
              for (int i = 0, size = mSpans.length; i < size; i++) {
                  Span span = mSpans[i];
                  span.setLine(alignLine);
              }
  
              layoutManager.requestSimpleAnimationsInNextLayout();
              layoutManager.requestLayout();
          }
      }