SnapHelper源碼深度解析

阿新 • • 發佈：2018-11-09

這就是並且 aps lse to do -o 平滑 href source

目錄介紹

01.SnapHelper簡單介紹
- 1.1 SnapHelper作用
- 1.2 SnapHelper類分析
- 1.3 LinearSnapHelper類分析
- 1.4 PagerSnapHelper類分析
02.SnapHelper源碼分析
- 2.1 attachToRecyclerView入口方法
- 2.2 SnapHelper的抽象方法
- 2.3 onFling方法源碼分析
03.LinearSnapHelper源碼分析
- 3.1 LinearSnapHelper實現功能
- 3.2 calculateDistanceToFinalSnap()方法源碼
- 3.3 findSnapView()方法源碼
- 3.4 findTargetSnapPosition()方法源碼
- 3.5 支持哪些LayoutManager
- 3.6 OrientationHelper類
- 3.7 estimateNextPositionDiffForFling計算偏移量
04.自定義SnapHelper類
- 4.1 業務需求
- 4.2 自定義helper類

好消息

博客筆記大匯總【16年3月到至今】，包括Java基礎及深入知識點，Android技術博客，Python學習筆記等等，還包括平時開發中遇到的bug匯總，當然也在工作之余收集了大量的面試題，長期更新維護並且修正，持續完善……開源的文件是markdown格式的！同時也開源了生活博客，從12年起，積累共計47篇[近20萬字]，轉載請註明出處，謝謝！

鏈接地址：https://github.com/yangchong211/YCBlogs
如果覺得好，可以star一下，謝謝！當然也歡迎提出建議，萬事起於忽微，量變引起質變！

01.SnapHelper簡單介紹

1.1 SnapHelper作用

在某些場景下，卡片列表滑動瀏覽[有的叫輪播圖]，希望當滑動停止時可以將當前卡片停留在屏幕某個位置，比如停在左邊，以吸引用戶的焦點。那麽可以使用RecyclerView + Snaphelper來實現，SnapHelper旨在支持RecyclerView的對齊方式，也就是通過計算對齊RecyclerView中TargetView 的指定點或者容器中的任何像素點。

1.2 SnapHelper類分析

查閱可知，SnapHelper繼承自RecyclerView.OnFlingListener，並且重寫了onFling方法，這個類代碼並不多，下面會對重要方法一一解析。
- 支持SnapHelper的RecyclerView.LayoutManager必須實現的方式：
  - RecyclerView.SmoothScroller.ScrollVectorProvider接口
  - 或者自己實現onFling(int,int)方法手動處理邏輯。
SnapHelper類重要的方法
- attachToRecyclerView: 將SnapHelper attach 到指定的RecyclerView 上。
- calculateDistanceToFinalSnap:復寫這個方法計算對齊到TargetView或容器指定點的距離，這是一個抽象方法，由子類自己實現，返回的是一個長度為2的int 數組out，out[0]是x方向對齊要移動的距離，out[1]是y方向對齊要移動的距離。
- calculateScrollDistance: 根據每個方向給定的速度估算滑動的距離，用於Fling 操作。
- findSnapView:提供一個指定的目標View 來對齊,抽象方法，需要子類實現
- findTargetSnapPosition:提供一個用於對齊的Adapter 目標position,抽象方法，需要子類自己實現。
- onFling:根據給定的x和 y 軸上的速度處理Fling。
什麽是Fling操作
- 手指在屏幕上滑動 RecyclerView然後松手，RecyclerView中的內容會順著慣性繼續往手指滑動的方向繼續滾動直到停止，這個過程叫做 Fling 。 Fling 操作從手指離開屏幕瞬間被觸發，在滾動停止時結束。

1.3 LinearSnapHelper類分析

LinearSnapHelper 使當前Item居中顯示，常用場景是橫向的RecyclerView，類似ViewPager效果，但是又可以快速滑動（滑動多頁）。

最簡單的使用就是，如下代碼

幾行代碼就可以用RecyclerView實現一個類似ViewPager的效果，並且效果還不錯。可以快速滑動多頁，當前頁劇中顯示，並且顯示前一頁和後一頁的部分。

private void initRecyclerView() {
    LinearLayoutManager manager = new LinearLayoutManager(this);
    manager.setOrientation(LinearLayoutManager.HORIZONTAL);
    mRecyclerView.setLayoutManager(manager);
    LinearSnapHelper snapHelper = new LinearSnapHelper();
    snapHelper.attachToRecyclerView(mRecyclerView);
    SnapAdapter adapter = new SnapAdapter(this);
    mRecyclerView.setAdapter(adapter);
    adapter.addAll(getData());
}

1.4 PagerSnapHelper類分析

PagerSnapHelper看名字可能就能猜到，使RecyclerView像ViewPager一樣的效果，每次只能滑動一頁（LinearSnapHelper支持快速滑動）, PagerSnapHelper也是Item居中對齊。

最簡單的使用就是，如下代碼

private void initRecyclerView() {
    LinearLayoutManager manager = new LinearLayoutManager(this);
    manager.setOrientation(LinearLayoutManager.HORIZONTAL);
    mRecyclerView.setLayoutManager(manager);
    PagerSnapHelper snapHelper = new PagerSnapHelper();
    snapHelper.attachToRecyclerView(mRecyclerView);
    SnapAdapter adapter = new SnapAdapter(this);
    mRecyclerView.setAdapter(adapter);
    adapter.addAll(getData());
}

02.SnapHelper源碼分析

2.1 attachToRecyclerView入口方法

通過attachToRecyclerView方法將SnapHelper attach 到RecyclerView，看一下這個方法的源代碼
- 如果SnapHelper之前已經附著到此RecyclerView上，則不用進行任何操作
- 如果SnapHelper之前附著的RecyclerView和現在的不一致，就將原來設置的回調全部remove或者設置為null
- 然後更新RecyclerView對象引用，Attach的RecyclerView不為null,設置回調Callback，主要包括滑動的回調和Fling操作的回調，初始化一個Scroller 用於後面做滑動處理，然後調用snapToTargetExistingView
- 大概流程就是：在attachToRecyclerView()方法中會清掉SnapHelper之前保存的RecyclerView對象的回調(如果有的話)，對新設置進來的RecyclerView對象設置回調,然後初始化一個Scroller對象,最後調用snapToTargetExistingView()方法對SnapView進行對齊調整。
```
public void attachToRecyclerView(@Nullable RecyclerView recyclerView)
        throws IllegalStateException {
    if (mRecyclerView == recyclerView) {
        return; // nothing to do
    }
    if (mRecyclerView != null) {
        destroyCallbacks();
    }
    mRecyclerView = recyclerView;
    if (mRecyclerView != null) {
        setupCallbacks();
        mGravityScroller = new Scroller(mRecyclerView.getContext(),
                new DecelerateInterpolator());
        snapToTargetExistingView();
    }
}
```

接著看看setupCallbacks()源碼

上面已經說了，滑動的回調和Fling操作的回調

private void setupCallbacks() throws IllegalStateException {
    if (mRecyclerView.getOnFlingListener() != null) {
        throw new IllegalStateException("An instance of OnFlingListener already set.");
    }
    mRecyclerView.addOnScrollListener(mScrollListener);
    mRecyclerView.setOnFlingListener(this);
}

接著看看snapToTargetExistingView()方法
- 這個方法用於第一次Attach到RecyclerView時對齊TargetView，或者當Scroll被觸發的時候和fling操作的時候對齊TargetView 。
- 判斷RecyclerView 和LayoutManager是否為null，接著調用findSnapView 方法來獲取需要對齊的目標View，註意：這是個抽象方法，需要子類實現
- 通過calculateDistanceToFinalSnap 獲取x方向和y方向對齊需要移動的距離
- 最後如果需要滾動的距離不是為0，就調用smoothScrollBy方法使RecyclerView滾動相應的距離
- 註意：RecyclerView.smoothScrollBy()這個方法的作用就是根據參數平滑滾動RecyclerView的中的ItemView相應的距離。
```
void snapToTargetExistingView() {
    if (mRecyclerView == null) {
        return;
    }
    LayoutManager layoutManager = mRecyclerView.getLayoutManager();
    if (layoutManager == null) {
        return;
    }
    View snapView = findSnapView(layoutManager);
    if (snapView == null) {
        return;
    }
    int[] snapDistance = calculateDistanceToFinalSnap(layoutManager, snapView);
    if (snapDistance[0] != 0 || snapDistance[1] != 0) {
        mRecyclerView.smoothScrollBy(snapDistance[0], snapDistance[1]);
    }
}
```

然後來看一下mScrollListener監聽裏面做了什麽

該滾動監聽器的實現很簡單，只是在正常滾動停止的時候調用了snapToTargetExistingView()方法對targetView進行滾動調整，以確保停止的位置是在對應的坐標上，這就是RecyclerView添加該OnScrollListener的目的。
mScrolled為true表示之前進行過滾動，newState為SCROLL_STATE_IDLE狀態表示滾動結束停下來

private final RecyclerView.OnScrollListener mScrollListener =
    new RecyclerView.OnScrollListener() {
        boolean mScrolled = false;

        @Override
        public void onScrollStateChanged(RecyclerView recyclerView, int newState) {
            super.onScrollStateChanged(recyclerView, newState);
            if (newState == RecyclerView.SCROLL_STATE_IDLE && mScrolled) {
                mScrolled = false;
                snapToTargetExistingView();
            }
        }

        @Override
        public void onScrolled(RecyclerView recyclerView, int dx, int dy) {
            if (dx != 0 || dy != 0) {
                mScrolled = true;
            }
        }
    };

2.2 SnapHelper的抽象方法

calculateDistanceToFinalSnap抽象方法
- 計算最終對齊要移動的距離
  - 計算二個參數對應的 ItemView 當前的坐標與需要對齊的坐標之間的距離。該方法返回一個大小為 2 的 int 數組，分別對應out[0] 為 x 方向移動的距離，out[1] 為 y 方向移動的距離。
```
@SuppressWarnings("WeakerAccess")
@Nullable
public abstract int[] calculateDistanceToFinalSnap(@NonNull LayoutManager layoutManager,
        @NonNull View targetView);
```
findSnapView抽象方法
- 找到要對齊的View
  - 該方法會找到當前 layoutManager 上最接近對齊位置的那個 view ，該 view 稱為 SanpView ，對應的 position 稱為 SnapPosition 。如果返回 null ，就表示沒有需要對齊的 View ，也就不會做滾動對齊調整。
```
@SuppressWarnings("WeakerAccess")
@Nullable
public abstract View findSnapView(LayoutManager layoutManager);
```
findTargetSnapPosition抽象方法
- 找到需要對齊的目標View的的Position。
  - 更加詳細一點說就是該方法會根據觸發 Fling 操作的速率（參數 velocityX 和參數 velocityY ）來找到 RecyclerView 需要滾動到哪個位置，該位置對應的 ItemView 就是那個需要進行對齊的列表項。我們把這個位置稱為 targetSnapPosition ，對應的 View 稱為 targetSnapView 。如果找不到 targetSnapPosition ，就返回RecyclerView.NO_POSITION 。
```
public abstract int findTargetSnapPosition(LayoutManager layoutManager, int velocityX,
        int velocityY);
```

2.3 onFling方法源碼分析

SnapHelper繼承了 RecyclerView.OnFlingListener，實現了onFling方法。

獲取RecyclerView要進行fling操作需要的最小速率，為啥呢？因為只有超過該速率，ItemView才會有足夠的動力在手指離開屏幕時繼續滾動下去。

@Override
public boolean onFling(int velocityX, int velocityY) {
    LayoutManager layoutManager = mRecyclerView.getLayoutManager();
    if (layoutManager == null) {
        return false;
    }
    RecyclerView.Adapter adapter = mRecyclerView.getAdapter();
    if (adapter == null) {
        return false;
    }
    int minFlingVelocity = mRecyclerView.getMinFlingVelocity();
    return (Math.abs(velocityY) > minFlingVelocity || Math.abs(velocityX) > minFlingVelocity)
            && snapFromFling(layoutManager, velocityX, velocityY);
}

接著看看snapFromFling方法源代碼，就是通過該方法實現平滑滾動並使得在滾動停止時itemView對齊到目的坐標位置
- 首先layoutManager必須實現ScrollVectorProvider接口才能繼續往下操作
- 然後通過createSnapScroller方法創建一個SmoothScroller，這個東西是一個平滑滾動器，用於對ItemView進行平滑滾動操作
- 根據x和y方向的速度來獲取需要對齊的View的位置，需要子類實現
- 最終通過 SmoothScroller 來滑動到指定位置
```
private boolean snapFromFling(@NonNull LayoutManager layoutManager, int velocityX,
        int velocityY) {
    if (!(layoutManager instanceof ScrollVectorProvider)) {
        return false;
    }

    RecyclerView.SmoothScroller smoothScroller = createSnapScroller(layoutManager);
    if (smoothScroller == null) {
        return false;
    }

    int targetPosition = findTargetSnapPosition(layoutManager, velocityX, velocityY);
    if (targetPosition == RecyclerView.NO_POSITION) {
        return false;
    }

    smoothScroller.setTargetPosition(targetPosition);
    layoutManager.startSmoothScroll(smoothScroller);
    return true;
}
```
- 總結一下可知：snapFromFling()方法會先判斷layoutManager是否實現了ScrollVectorProvider接口，如果沒有實現該接口就不允許通過該方法做滾動操作。接下來就去創建平滑滾動器SmoothScroller的一個實例，layoutManager可以通過該平滑滾動器來進行滾動操作。SmoothScroller需要設置一個滾動的目標位置，將通過findTargetSnapPosition()方法來計算得到的targetSnapPosition給它，告訴滾動器要滾到這個位置，然後就啟動SmoothScroller進行滾動操作。

接著看下createSnapScroller這個方法源碼

先判斷layoutManager是否實現了ScrollVectorProvider這個接口，沒有實現該接口就不創建SmoothScroller
這裏創建一個LinearSmoothScroller對象，然後返回給調用函數，也就是說，最終創建出來的平滑滾動器就是這個LinearSmoothScroller
在創建該LinearSmoothScroller的時候主要考慮兩個方面：
- 第一個是滾動速率，由calculateSpeedPerPixel()方法決定；
- 第二個是在滾動過程中，targetView即將要進入到視野時，將勻速滾動變換為減速滾動，然後一直滾動目的坐標位置，使滾動效果更真實，這是由onTargetFound()方法決定。

@Nullable
protected LinearSmoothScroller createSnapScroller(LayoutManager layoutManager) {
    if (!(layoutManager instanceof ScrollVectorProvider)) {
        return null;
    }
    return new LinearSmoothScroller(mRecyclerView.getContext()) {
        @Override
        protected void onTargetFound(View targetView, RecyclerView.State state, Action action) {
            int[] snapDistances = calculateDistanceToFinalSnap(mRecyclerView.getLayoutManager(),
                    targetView);
            final int dx = snapDistances[0];
            final int dy = snapDistances[1];
            final int time = calculateTimeForDeceleration(Math.max(Math.abs(dx), Math.abs(dy)));
            if (time > 0) {
                action.update(dx, dy, time, mDecelerateInterpolator);
            }
        }

        @Override
        protected float calculateSpeedPerPixel(DisplayMetrics displayMetrics) {
            return MILLISECONDS_PER_INCH / displayMetrics.densityDpi;
        }
    };
}

03.LinearSnapHelper源碼分析

3.1 LinearSnapHelper實現功能

LinearSnapHelper實現了SnapHelper，並且實現SnapHelper的三個抽象方法，從而讓ItemView滾動居中對齊。那麽具體怎麽做到呢？

3.2 calculateDistanceToFinalSnap()方法源碼

calculateDistanceToFinalSnap源碼如下所示

如果是水平方向滾動的，則計算水平方向需要移動的距離，否則水平方向的移動距離為0
如果是豎直方向滾動的，則計算豎直方向需要移動的距離，否則豎直方向的移動距離為0
distanceToCenter方法主要作用是：計算水平或者豎直方向需要移動的距離

@Override
public int[] calculateDistanceToFinalSnap(
        @NonNull RecyclerView.LayoutManager layoutManager, @NonNull View targetView) {
    int[] out = new int[2];
    if (layoutManager.canScrollHorizontally()) {
        out[0] = distanceToCenter(layoutManager, targetView,
                getHorizontalHelper(layoutManager));
    } else {
        out[0] = 0;
    }

    if (layoutManager.canScrollVertically()) {
        out[1] = distanceToCenter(layoutManager, targetView,
                getVerticalHelper(layoutManager));
    } else {
        out[1] = 0;
    }
    return out;
}

接著看看distanceToCenter方法

計算對應的view的中心坐標到RecyclerView中心坐標之間的距離
首先是找到targetView的中心坐標
接著也就是找到容器【RecyclerView】的中心坐標
兩個中心坐標的差值就是targetView需要滾動的距離

private int distanceToCenter(@NonNull RecyclerView.LayoutManager layoutManager,
        @NonNull View targetView, OrientationHelper helper) {
    final int childCenter = helper.getDecoratedStart(targetView)
            + (helper.getDecoratedMeasurement(targetView) / 2);
    final int containerCenter;
    if (layoutManager.getClipToPadding()) {
        containerCenter = helper.getStartAfterPadding() + helper.getTotalSpace() / 2;
    } else {
        containerCenter = helper.getEnd() / 2;
    }
    return childCenter - containerCenter;
}

3.3 findSnapView()方法源碼

也就是找到要對齊的View

根據layoutManager的布局方式（水平布局方式或者豎向布局方式）區分計算，但最終都是通過findCenterView()方法來找snapView的。

@Override
public View findSnapView(RecyclerView.LayoutManager layoutManager) {
    if (layoutManager.canScrollVertically()) {
        return findCenterView(layoutManager, getVerticalHelper(layoutManager));
    } else if (layoutManager.canScrollHorizontally()) {
        return findCenterView(layoutManager, getHorizontalHelper(layoutManager));
    }
    return null;
}

接著看看findCenterView方法源代碼

查詢當前是否支持垂直滾動還是橫向滾動
循環LayoutManager的所有子元素，計算每個 childView的中點距離Parent 的中點，找到距離最近的一個，就是需要居中對齊的目標View

@Nullable
private View findCenterView(RecyclerView.LayoutManager layoutManager,
        OrientationHelper helper) {
    int childCount = layoutManager.getChildCount();
    if (childCount == 0) {
        return null;
    }

    View closestChild = null;
    final int center;
    if (layoutManager.getClipToPadding()) {
        center = helper.getStartAfterPadding() + helper.getTotalSpace() / 2;
    } else {
        center = helper.getEnd() / 2;
    }
    int absClosest = Integer.MAX_VALUE;

    for (int i = 0; i < childCount; i++) {
        final View child = layoutManager.getChildAt(i);
        int childCenter = helper.getDecoratedStart(child)
                + (helper.getDecoratedMeasurement(child) / 2);
        int absDistance = Math.abs(childCenter - center);

        /** if child center is closer than previous closest, set it as closest  **/
        if (absDistance < absClosest) {
            absClosest = absDistance;
            closestChild = child;
        }
    }
    return closestChild;
}

3.4 findTargetSnapPosition()方法源碼

LinearSnapHelper實現了SnapHelper，來看一下在findTargetSnapPosition操作了什麽

如果是水平方向滾動的列表，估算出水平方向SnapHelper響應fling，對齊要滑動的position和當前position的差，否則，水平方向滾動的差值為0
如果是豎直方向滾動的列表，估算出豎直方向SnapHelper響應fling，對齊要滑動的position和當前position的差，否則，豎直方向滾動的差值為0
這個方法在計算targetPosition的時候把布局方式和布局方向都考慮進去了。布局方式可以通過layoutManager.canScrollHorizontally()/layoutManager.canScrollVertically()來判斷，布局方向就通過RecyclerView.SmoothScroller.ScrollVectorProvider這個接口中的computeScrollVectorForPosition()方法來判斷。

@Override
public int findTargetSnapPosition(RecyclerView.LayoutManager layoutManager, int velocityX,
        int velocityY) {
    if (!(layoutManager instanceof RecyclerView.SmoothScroller.ScrollVectorProvider)) {
        return RecyclerView.NO_POSITION;
    }

    final int itemCount = layoutManager.getItemCount();
    if (itemCount == 0) {
        return RecyclerView.NO_POSITION;
    }

    final View currentView = findSnapView(layoutManager);
    if (currentView == null) {
        return RecyclerView.NO_POSITION;
    }

    final int currentPosition = layoutManager.getPosition(currentView);
    if (currentPosition == RecyclerView.NO_POSITION) {
        return RecyclerView.NO_POSITION;
    }

    RecyclerView.SmoothScroller.ScrollVectorProvider vectorProvider =
            (RecyclerView.SmoothScroller.ScrollVectorProvider) layoutManager;
    // deltaJumps sign comes from the velocity which may not match the order of children in
    // the LayoutManager. To overcome this, we ask for a vector from the LayoutManager to
    // get the direction.
    PointF vectorForEnd = vectorProvider.computeScrollVectorForPosition(itemCount - 1);
    if (vectorForEnd == null) {
        // cannot get a vector for the given position.
        return RecyclerView.NO_POSITION;
    }

    int vDeltaJump, hDeltaJump;
    if (layoutManager.canScrollHorizontally()) {
        hDeltaJump = estimateNextPositionDiffForFling(layoutManager,
                getHorizontalHelper(layoutManager), velocityX, 0);
        if (vectorForEnd.x < 0) {
            hDeltaJump = -hDeltaJump;
        }
    } else {
        hDeltaJump = 0;
    }
    if (layoutManager.canScrollVertically()) {
        vDeltaJump = estimateNextPositionDiffForFling(layoutManager,
                getVerticalHelper(layoutManager), 0, velocityY);
        if (vectorForEnd.y < 0) {
            vDeltaJump = -vDeltaJump;
        }
    } else {
        vDeltaJump = 0;
    }

    int deltaJump = layoutManager.canScrollVertically() ? vDeltaJump : hDeltaJump;
    if (deltaJump == 0) {
        return RecyclerView.NO_POSITION;
    }

    int targetPos = currentPosition + deltaJump;
    if (targetPos < 0) {
        targetPos = 0;
    }
    if (targetPos >= itemCount) {
        targetPos = itemCount - 1;
    }
    return targetPos;
}

3.5 支持哪些LayoutManager

SnapHelper為了適配layoutManager的各種情況，特意要求只有實現了RecyclerView.SmoothScroller.ScrollVectorProvider接口的layoutManager才能使用SnapHelper進行輔助滾動對齊。官方提供的LinearLayoutManager、GridLayoutManager和StaggeredGridLayoutManager都實現了這個接口，所以都支持SnapHelper。

3.6 OrientationHelper類

如何創建OrientationHelper對象呢？如下所示

比如，上面三個抽象方法都使用到了這個類，這個類是幹嘛的？
計算位置的時候用的是OrientationHelper這個工具類，它是LayoutManager用於測量child的一個輔助類，可以根據Layoutmanager的布局方式和布局方向來計算得到ItemView的大小位置等信息。

@NonNull
private OrientationHelper getVerticalHelper(@NonNull RecyclerView.LayoutManager layoutManager) {
    if (mVerticalHelper == null || mVerticalHelper.mLayoutManager != layoutManager) {
        mVerticalHelper = OrientationHelper.createVerticalHelper(layoutManager);
    }
    return mVerticalHelper;
}

@NonNull
private OrientationHelper getHorizontalHelper(
        @NonNull RecyclerView.LayoutManager layoutManager) {
    if (mHorizontalHelper == null || mHorizontalHelper.mLayoutManager != layoutManager) {
        mHorizontalHelper = OrientationHelper.createHorizontalHelper(layoutManager);
    }
    return mHorizontalHelper;
}

3.7 estimateNextPositionDiffForFling計算偏移量

如下所示

首先，計算滾動的總距離，這個距離受到觸發fling時的速度的影響，得到一個distances數組
然後計算每個ItemView的長度
根據是橫向布局還是縱向布局，來取對應布局方向上的滾動距離
總結大概流程就是：用滾動總距離除以itemview的長度，從而估算得到需要滾動的item數量，此數值就是位置偏移量。而滾動距離是通過SnapHelper的calculateScrollDistance（）方法得到的，ItemView的長度是通過computeDistancePerChild（）方法計算出來。

private int estimateNextPositionDiffForFling(RecyclerView.LayoutManager layoutManager,
        OrientationHelper helper, int velocityX, int velocityY) {
    int[] distances = calculateScrollDistance(velocityX, velocityY);
    float distancePerChild = computeDistancePerChild(layoutManager, helper);
    if (distancePerChild <= 0) {
        return 0;
    }
    int distance =
            Math.abs(distances[0]) > Math.abs(distances[1]) ? distances[0] : distances[1];
    return (int) Math.round(distance / distancePerChild);
}

04.自定義SnapHelper類

4.1 業務需求

LinearSnapHelper 實現了居中對齊，那麽我們只要更改一下對齊的規則就行，更改為開始對齊（計算目標 View到 Parent start 要滑動的距離），其他的邏輯和 LinearSnapHelper 是一樣的。因此我們選擇繼承 LinearSnapHelper
大概流程
- 重寫calculateDistanceToFinalSnap方法，計算SnapView當前位置與目標位置的距離
- 寫findSnapView方法，找到當前時刻的SnapView
- 可以發現完成上面兩個方法就可以呢，但是感覺滑動效果不太好。滑動比較快時，會滾動很遠。在分析了上面的代碼可知，滾動速率，由createSnapScroller方法中的calculateSpeedPerPixel()方法決定。那麽是不是可以修改一下速率就可以解決問題呢。最後測試真的可以，ok，完成了。
- 當然還會發現滾動時候，會滑動多個item，如果相對item個數做限制，可以在findTargetSnapPosition()方法中處理。
代碼地址：https://github.com/yangchong211/YCBanner

4.2 自定義helper類

重寫calculateDistanceToFinalSnap方法

這裏需要知道，在LinearSnapHelper中，out[0]和out[1]是通過distanceToCenter獲取的。那麽既然要設置開始對齊，那麽這裏需要創建distanceToStart方法

@Nullable
@Override
public int[] calculateDistanceToFinalSnap(RecyclerView.LayoutManager layoutManager, View targetView) {
    int[] out = new int[2];
    if (layoutManager.canScrollHorizontally()) {
        out[0] = distanceToStart(targetView, getHorizontalHelper(layoutManager));
    } else {
        out[0] = 0;
    }
    if (layoutManager.canScrollVertically()) {
        out[1] = distanceToStart(targetView, getVerticalHelper(layoutManager));
    } else {
        out[1] = 0;
    }
    return out;
}

private int distanceToStart(View targetView, OrientationHelper helper) {
    return helper.getDecoratedStart(targetView) - helper.getStartAfterPadding();
}

寫findSnapView方法，找到當前時刻的SnapView

@Nullable
@Override
public View findSnapView(RecyclerView.LayoutManager layoutManager) {
    if (layoutManager instanceof LinearLayoutManager) {
        if (layoutManager.canScrollHorizontally()) {
            return findStartView(layoutManager, getHorizontalHelper(layoutManager));
        } else {
            return findStartView(layoutManager, getVerticalHelper(layoutManager));
        }
    }
    return super.findSnapView(layoutManager);
}

private View findStartView(RecyclerView.LayoutManager layoutManager, OrientationHelper helper) {
    if (layoutManager instanceof LinearLayoutManager) {
        int firstChild = ((LinearLayoutManager) layoutManager).findFirstVisibleItemPosition();
        //需要判斷是否是最後一個Item，如果是最後一個則不讓對齊，以免出現最後一個顯示不完全。
        boolean isLastItem = ((LinearLayoutManager) layoutManager).findLastCompletelyVisibleItemPosition()
                == layoutManager.getItemCount() - 1;
        if (firstChild == RecyclerView.NO_POSITION || isLastItem) {
            return null;
        }
        View child = layoutManager.findViewByPosition(firstChild);
        if (helper.getDecoratedEnd(child) >= helper.getDecoratedMeasurement(child) / 2
                && helper.getDecoratedEnd(child) > 0) {
            return child;
        } else {
            if (((LinearLayoutManager) layoutManager).findLastCompletelyVisibleItemPosition()
                    == layoutManager.getItemCount() - 1) {
                return null;
            } else {
                return layoutManager.findViewByPosition(firstChild + 1);
            }
        }
    }
    return super.findSnapView(layoutManager);
}

修改滾動速率

@Nullable
protected LinearSmoothScroller createSnapScroller(final RecyclerView.LayoutManager layoutManager) {
    if (!(layoutManager instanceof RecyclerView.SmoothScroller.ScrollVectorProvider)) {
        return null;
    }
    return new LinearSmoothScroller(mRecyclerView.getContext()) {
        @Override
        protected void onTargetFound(View targetView, RecyclerView.State state, RecyclerView.SmoothScroller.Action action) {
            int[] snapDistances = calculateDistanceToFinalSnap(mRecyclerView.getLayoutManager(), targetView);
            final int dx;
            final int dy;
            if (snapDistances != null) {
                dx = snapDistances[0];
                dy = snapDistances[1];
                final int time = calculateTimeForDeceleration(Math.max(Math.abs(dx), Math.abs(dy)));
                if (time > 0) {
                    action.update(dx, dy, time, mDecelerateInterpolator);
                }
            }
        }

        @Override
        protected float calculateSpeedPerPixel(DisplayMetrics displayMetrics) {
            //這個地方可以自己設置
            return MILLISECONDS_PER_INCH / displayMetrics.densityDpi;
        }
    };
}

關於其他內容介紹

技術分享圖片

關於其他內容介紹

01.關於博客匯總鏈接

1.技術博客匯總
2.開源項目匯總
3.生活博客匯總
4.喜馬拉雅音頻匯總
5.其他匯總

02.關於我的博客

我的個人站點：www.yczbj.org，www.ycbjie.cn
github：https://github.com/yangchong211
知乎：https://www.zhihu.com/people/yang-chong-69-24/pins/posts
簡書：http://www.jianshu.com/u/b7b2c6ed9284
csdn：http://my.csdn.net/m0_37700275
喜馬拉雅聽書：http://www.ximalaya.com/zhubo/71989305/
開源中國：https://my.oschina.net/zbj1618/blog
泡在網上的日子：http://www.jcodecraeer.com/member/content_list.php?channelid=1
郵箱：[email protected]
阿裏雲博客：https://yq.aliyun.com/users/article?spm=5176.100- 239.headeruserinfo.3.dT4bcV
segmentfault頭條：https://segmentfault.com/u/xiangjianyu/articles

SnapHelper源碼深度解析

這就是並且 aps lse to do -o 平滑 href source 目錄介紹 01.SnapHelper簡單介紹 1.1 SnapHelper作用 1.2 SnapHelper類分析 1.3 LinearSnapHelper類分析 1.4 PagerSnapH

Spring源碼深度解析（一）

聯盟容器代碼 beans 管理 servle text spring框架講解　　Spring整體架構分為以下幾部分：　　　　1.Core模塊：包含Spring框架的基本核心工具類，Spring其它組件都要使用到這個包中的類，Core模塊是其它組件的基本核心。　　

VueRouter 源碼深度解析

hist ati 實例開始不可 getc ise config mode VueRouter 源碼深度解析該文章內容節選自團隊的開源項目 InterviewMap。項目目前內容包含了 JS、網絡、瀏覽器相關、性能優化、安全、框架、Git、數據結構、算法等內容

書籍摘要-spring 源碼深度解析

不同的 jdbc context 數據庫連接實現類 spa api 循環摘要第 1 章：spring 整體架構和環境搭建　　spring 是分層的，主要分為網絡層、數據庫連接層、核心容器層、 AOP 層和測試層。　　核心容器中實現了 IOC 和依賴註入，方法是

JAVA框架底層源碼剖析系列Spring，Mybatis，Springboot，Netty源碼深度解析

spring 消費者接口 jdbc 剖析 tty 必須實戰整體架構《Spring源碼深度解析》從核心實現和企業應用兩個方面，由淺入深、由易到難地對Spring源碼展開了系統的講解，包括Spring的設計理念和整體架構、容器的基本實現、默認標簽的解析、自定義標簽的解析

Springboot源碼深度解析，方法解析，類加載解析，容器建立

加載類 duplicate turn getclass for main方法 gin unique 所有 springboot的啟動都是從main方法開始的，如下：@SpringBootApplicationpublic class Application { pub

MySQL半一致性讀原理解析-從源碼角度解析

InnoDB 半一致性讀1、什麽是半一致性讀 A type of read operation used for UPDATE statements, that is a combination of read committed and consistent read. When an UPDATE sta

Java 集合Vector源碼深入解析

java 集合源碼概論學完ArrayList和LinkedList之後，我們接著學習Vector。學習方式還是和之前一樣，先對Vector有個整體認識，然後再學習它的源碼；最後再通過實例來學會使用它。第1部分 Vector介紹 Vector簡介 Vector 是矢量隊列，它是JDK1.0版本添加

Java集合Stack源碼深入解析

java源碼概要學完Vector了之後，接下來我們開始學習Stack。Stack很簡單，它繼承於Vector。學習方式還是和之前一樣，先對Stack有個整體認識，然後再學習它的源碼；最後再通過實例來學會使用它。第1部分 Stack介紹 Stack簡介 Stack是棧。它的特性是：先進後出(FILO, Fi

flask-Local源碼流程解析

pmo get_id exc 源碼 [] nbsp gree ESS func flask中Local源碼數據類型首先明確：源碼中要構造的數據類型數是這樣的： __storage__ = { 用線程或者協程的唯一標識為鍵: {stack:[ctx(session/

HandlerThread 特點和北京pk10源碼搭建解析

fault ref prot instead all link ron ready name HandlerThread北京pk10源碼網站搭建解析因為源碼很簡短，這裏就全部粘貼過來了。 /** Handy class for starting a new thread

開啟vue源碼的解析攻略---認識flow

相關 size ddc div 類型動態開頭 pes ray javascript 是動態類型的代碼，有很多的寫法很不容易報錯，想引入靜態類型檢查的flow,之前做項目的時候用的typascript的，看的大概的寫法和 typescript 類似，因為規

Java7 ConcurrentHashMap源碼深入解析

都沒有 oca service != bre sock 可見性 des tor ConcurrentHashMap 和 HashMap 思路是差不多的，但是因為它支持並發操作，所以要復雜一些。整個 ConcurrentHashMap 由一個個 Segment 組成，Seg

Toast源碼深度分析

move obsolete def DApp 前臺 remove state sim 更多目錄介紹 1.最簡單的創建方法 1.1 Toast構造方法 1.2 最簡單的創建 1.3 簡單改造避免重復創建 1.4 為何會出現內存泄漏 1.5 吐司是系統級別的 2.源碼分

netty源碼解解析(4.0)-1 核心架構

coder style out ava 默認 mage 網絡框架分享圖片輸入 netty是java開源社區的一個優秀的網絡框架。使用netty，我們可以迅速地開發出穩定，高性能，安全的，擴展性良好的服務器應用程序。netty封裝簡化了在服務器開發領域的一些有挑戰性的問題

netty源碼解解析(4.0)-8 ChannelPipeline的設計

rst 分配 active ace 時間 rev remove 設置 bject io.netty.channel.ChannelPipeline 設計原理　　　　上圖中，為了更直觀地展示事件處理順序, 故意有規律地放置兩種handler的順序，實際上Chann

HashMap和ConcurrentHashMap 源碼關鍵點解析

pack https -a 加鎖 this 系列文章如果 zha 是不是第一部分：關鍵源碼講解 1.HashMap 是如何存儲的？ a.底層是一個數組 tab b. hash=hash(key) ，然後根據數組長度n和hash值，決定當前需要put的元素對應的數組下標

netty源碼解解析(4.0)-14 Channel NIO實現:讀取數據

isa index 消息 soc 發現接收數據 boolean 是的 cte 　　本章分析Nio Channel的數據讀取功能的實現。　　Channel讀取數據需要Channel和ChannelHandler配合使用，netty設計數據讀取功能包括三個要素：Chan

StringBudiler源碼簡單解析

字符串復制 main 是不是調用當前 arrays println 第一個 StringBudiler源碼繼承關系樹底層實現默認容量() 特別的添加方法(append) 1、繼承關系樹繼承自AbstractStringBuilder與StringBuffe

從源碼角度解析Netty的React模式是如何工作的

簡單 net multi 邏輯初始化 lec RKE con acceptor Netty 支持多種實現方式，比如nio,epoll 等，本文以nio的實現方式進行講解。 1.EventLoop : 事件循環看，簡單來說就是一個死循環監聽事件，如果事件來了，處理掉。通

SnapHelper源碼深度解析

目錄介紹

好消息

01.SnapHelper簡單介紹

1.1 SnapHelper作用

1.2 SnapHelper類分析

1.3 LinearSnapHelper類分析

1.4 PagerSnapHelper類分析

02.SnapHelper源碼分析

2.1 attachToRecyclerView入口方法

2.2 SnapHelper的抽象方法

2.3 onFling方法源碼分析

03.LinearSnapHelper源碼分析

3.1 LinearSnapHelper實現功能

3.2 calculateDistanceToFinalSnap()方法源碼

3.3 findSnapView()方法源碼

3.4 findTargetSnapPosition()方法源碼

3.5 支持哪些LayoutManager

3.6 OrientationHelper類

3.7 estimateNextPositionDiffForFling計算偏移量

04.自定義SnapHelper類

4.1 業務需求

4.2 自定義helper類

關於其他內容介紹

關於其他內容介紹

01.關於博客匯總鏈接

02.關於我的博客

相關推薦