自定義View事件之進階篇(一)-NestedScrolling(嵌套滑動)機制
最近一段時間，一直都在忙於找工做。雖然花費了三個月的時間，可是結果並非很美滿。想去大廠、想去好公司、想碰見更厲害的人的願望仍是沒有實現。或許是本身不夠強大，或許本身不夠努力，或許須要必定運氣。生活老是須要經歷一些波折。沒有誰老是能一路順風。接下來一段時間內，會繼續更新文章。但願你們能繼續關注。Thanks~java
前言
在Lollipop(Android 5.0)時，谷歌推出了NestedScrolling機制，也就是嵌套滑動。本文將帶領你們一塊兒去了解谷歌對該機制的設計。經過閱讀該文，你能瞭解以下知識點：git
- 傳統事件分發機制中嵌套滑動的實現與侷限性。
- 谷歌NestedScrolling機制的原理實現。
- NestedScrollingChild與NestedScrollingParent接口的調用關係。
- NestedScrollingChild2與NestedScrollingParent2接口出現的意義。
該博客中涉及到的示例，在NestedScrollingDemo項目中都有實現，你們能夠按需自取。github
傳統事件機制處理嵌套滑動的侷限性
在傳統的事件分發機制中，當一個事件產生後，它的傳遞過程遵循以下順序:父控件->子控件,事件老是先傳遞給父控件,當父控件不對事件攔截的時候，那麼當前事件又會傳遞給它的子控件。一旦父控件須要攔截事件，那麼子控件是沒有機會接受該事件的。算法
所以當在傳統事件分發機制中，若是有嵌套滑動場景，咱們須要手動解決事件衝突。具體嵌套滑動例子以下圖所示：數組
上述效果實現，請參看NestedTraditionLayout.javaapp
想要實現上圖效果，在傳統滑動機制中，咱們須要如下幾個步驟：ide
- 咱們須要調用父控件中onInterceptTouchEvent方法來攔截向上滑動。
- 當父控件攔截事件後，須要控制自身的onTouchEvent處理滑動事件,使其滑動至HeaderView隱藏。
- 當HeaderView滑動至隱藏後，父控件就不攔截事件了，而是交給內部的子控件（RecyclerView或ListView)處理滑動事件。
使用傳統的事件攔截機制來處理嵌套滑動，咱們會發現一個問題，就是整個嵌套滑動是不連貫的。也就是當父控件滑動至HeaderView隱藏的時候，這個時候若是想要內部的（RecyclerView或ListView)處理滑動事件。只有擡起手指，從新向上滑動。函數
熟悉事件分發機制的朋友應該知道，之因此產生不連貫的緣由，是由於父控件攔截了事件，因此同一事件序列的事件，仍然會傳遞給父控件，也就會調用其onTouchEvent方法。而不是調用子控件的onTouchEvent方法。post
NestedScrolling機制簡介
爲了實現連貫的嵌套滑動，谷歌在Lollipop(Android 5.0)時，推出了NestedScrolling機制。該機制並無脫離傳統的事件分發機制，而是在原有的事件分發機制之上，爲系統的自帶的ViewGroup和View都增長了手勢滑動與處理fling的方法。同時爲了兼容低版本(5.0如下，View與ViewGroup是沒有對應的API)，谷歌也在support v4包中也提供了以下類與接口進行支撐：ui
父控件須要實現的接口與使用到的類：
- NestedScrollingParent（接口）
- NestedScrollingParent2（也是接口並繼承NestedScrollingParent）
- NestedScrollingParentHelper（類）
子控件須要實現的接口與使用到的類：
- NestedScrollingChild（接口）
- NestedScrollingChild2（也是接口並繼承NestedScrollingChild）
- NestedScrollingChildHelper（類）
須要注意的是，若是你的Android平臺在5.0以上，那麼你能夠直接使用系統ViewGoup與View自帶的方法。可是爲了向下兼容，建議仍是使用support v4包提供的相應接口來實現嵌套滑動。下文也會着重講解這些接口的的使用方式與方法說明。
NestedScrollingParent與NestedScrollingChild接口介紹
在瞭解嵌套滑動具體的使用方式以前，咱們須要瞭解父控件與子控件對應接口中方法的說明。這裏你們能夠先忽略掉NestedScrollingParent2與NestedScrollingChild2接口，由於這兩個接口是爲了解決以前對嵌套滑動處理fling效果的Bug。因此對於目前階段的咱們只須要了解基礎的嵌套滑動規則就夠了。關於NestedScrollingParent2與NestedScrollingChild2接口相關的知識點，會在下文具體描述。那如今咱們就先看看基礎的接口的方法介紹吧。
NestedScrollingParent
若是採用接口的方式實現嵌套滑動，咱們須要父控件要實現NestedScrollingParent接口。接口具體方法以下：
/** * 有嵌套滑動到來了，判斷父控件是否接受嵌套滑動 * * @param child 嵌套滑動對應的父類的子類(由於嵌套滑動對於的父控件不必定是一級就能找到的，可能挑了兩級父控件的父控件，child的輩分>=target) * @param target 具體嵌套滑動的那個子類 * @param nestedScrollAxes 支持嵌套滾動軸。水平方向，垂直方向，或者不指定 * @return 父控件是否接受嵌套滑動， 只有接受了纔會執行剩下的嵌套滑動方法 */
public boolean onStartNestedScroll(View child, View target, int nestedScrollAxes) {}
/** * 當onStartNestedScroll返回爲true時，也就是父控件接受嵌套滑動時，該方法纔會調用 */
public void onNestedScrollAccepted(View child, View target, int axes) {}
/** * 在嵌套滑動的子控件未滑動以前，判斷父控件是否優先與子控件處理(也就是父控件能夠先消耗，而後給子控件消耗） * * @param target 具體嵌套滑動的那個子類 * @param dx 水平方向嵌套滑動的子控件想要變化的距離 dx<0 向右滑動 dx>0 向左滑動 * @param dy 垂直方向嵌套滑動的子控件想要變化的距離 dy<0 向下滑動 dy>0 向上滑動 * @param consumed 這個參數要咱們在實現這個函數的時候指定，回頭告訴子控件當前父控件消耗的距離 * consumed[0] 水平消耗的距離，consumed[1] 垂直消耗的距離 好讓子控件作出相應的調整 */
public void onNestedPreScroll(View target, int dx, int dy, int[] consumed) {}
/** * 嵌套滑動的子控件在滑動以後，判斷父控件是否繼續處理（也就是父消耗必定距離後，子再消耗，最後判斷父消耗不） * * @param target 具體嵌套滑動的那個子類 * @param dxConsumed 水平方向嵌套滑動的子控件滑動的距離(消耗的距離) * @param dyConsumed 垂直方向嵌套滑動的子控件滑動的距離(消耗的距離) * @param dxUnconsumed 水平方向嵌套滑動的子控件未滑動的距離(未消耗的距離) * @param dyUnconsumed 垂直方向嵌套滑動的子控件未滑動的距離(未消耗的距離) */
public void onNestedScroll(View target, int dxConsumed, int dyConsumed, int dxUnconsumed, int dyUnconsumed) {}
/** * 嵌套滑動結束 */
public void onStopNestedScroll(View child) {}
/** * 當子控件產生fling滑動時，判斷父控件是否處攔截fling，若是父控件處理了fling，那子控件就沒有辦法處理fling了。 * * @param target 具體嵌套滑動的那個子類 * @param velocityX 水平方向上的速度 velocityX > 0 向左滑動，反之向右滑動 * @param velocityY 豎直方向上的速度 velocityY > 0 向上滑動，反之向下滑動 * @return 父控件是否攔截該fling */
public boolean onNestedPreFling(View target, float velocityX, float velocityY) {}
/** * 當父控件不攔截該fling,那麼子控件會將fling傳入父控件 * * @param target 具體嵌套滑動的那個子類 * @param velocityX 水平方向上的速度 velocityX > 0 向左滑動，反之向右滑動 * @param velocityY 豎直方向上的速度 velocityY > 0 向上滑動，反之向下滑動 * @param consumed 子控件是否能夠消耗該fling，也能夠說是子控件是否消耗掉了該fling * @return 父控件是否消耗了該fling */
public boolean onNestedFling(View target, float velocityX, float velocityY, boolean consumed) {}
/** * 返回當前父控件嵌套滑動的方向，分爲水平方向與，垂直方法，或者不變 */
public int getNestedScrollAxes() {}
複製代碼
NestedScrollingChild接口介紹
若是採用接口的方式實現嵌套滑動，子控件須要實現NestedScrollingChild接口。接口具體方法以下：
/** * 開啓一個嵌套滑動 * * @param axes 支持的嵌套滑動方法，分爲水平方向，豎直方向，或不指定 * @return 若是返回true, 表示當前子控件已經找了一塊兒嵌套滑動的view */
public boolean startNestedScroll(int axes) {}
/** * 在子控件滑動前，將事件分發給父控件，由父控件判斷消耗多少 * * @param dx 水平方向嵌套滑動的子控件想要變化的距離 dx<0 向右滑動 dx>0 向左滑動 * @param dy 垂直方向嵌套滑動的子控件想要變化的距離 dy<0 向下滑動 dy>0 向上滑動 * @param consumed 子控件傳給父控件數組，用於存儲父控件水平與豎直方向上消耗的距離，consumed[0] 水平消耗的距離，consumed[1] 垂直消耗的距離 * @param offsetInWindow 子控件在當前window的偏移量 * @return 若是返回true, 表示父控件已經消耗了 */
public boolean dispatchNestedPreScroll(int dx, int dy, @Nullable int[] consumed, @Nullable int[] offsetInWindow) {}
/** * 當父控件消耗事件後，子控件處理後，又繼續將事件分發給父控件,由父控件判斷是否消耗剩下的距離。 * * @param dxConsumed 水平方向嵌套滑動的子控件滑動的距離(消耗的距離) * @param dyConsumed 垂直方向嵌套滑動的子控件滑動的距離(消耗的距離) * @param dxUnconsumed 水平方向嵌套滑動的子控件未滑動的距離(未消耗的距離) * @param dyUnconsumed 垂直方向嵌套滑動的子控件未滑動的距離(未消耗的距離) * @param offsetInWindow 子控件在當前window的偏移量 * @return 若是返回true, 表示父控件又繼續消耗了 */
public boolean dispatchNestedScroll(int dxConsumed, int dyConsumed, int dxUnconsumed, int dyUnconsumed, @Nullable int[] offsetInWindow) {}
/** * 子控件中止嵌套滑動 */
public void stopNestedScroll() {}
/** * 當子控件產生fling滑動時，判斷父控件是否處攔截fling，若是父控件處理了fling，那子控件就沒有辦法處理fling了。 * * @param velocityX 水平方向上的速度 velocityX > 0 向左滑動，反之向右滑動 * @param velocityY 豎直方向上的速度 velocityY > 0 向上滑動，反之向下滑動 * @return 若是返回true, 表示父控件攔截了fling */
public boolean dispatchNestedPreFling(float velocityX, float velocityY) {}
/** * 當父控件不攔截子控件的fling,那麼子控件會調用該方法將fling，傳給父控件進行處理 * * @param velocityX 水平方向上的速度 velocityX > 0 向左滑動，反之向右滑動 * @param velocityY 豎直方向上的速度 velocityY > 0 向上滑動，反之向下滑動 * @param consumed 子控件是否能夠消耗該fling，也能夠說是子控件是否消耗掉了該fling * @return 父控件是否消耗了該fling */
public boolean dispatchNestedFling(float velocityX, float velocityY, boolean consumed) {}
/** * 設置當前子控件是否支持嵌套滑動，若是不支持，那麼父控件是不可以響應嵌套滑動的 * * @param enabled true 支持 */
public void setNestedScrollingEnabled(boolean enabled) {}
/** * 當前子控件是否支持嵌套滑動 */
public boolean isNestedScrollingEnabled() {}
/** * 判斷當前子控件是否擁有嵌套滑動的父控件 */
public boolean hasNestedScrollingParent() {}
複製代碼
谷歌嵌套滑動的方法調用設計
經過上文，我相信你們大概基本瞭解了NestedScrollingParent與NestedScrollingChild兩個接口方法的做用，可是咱們並不知道這些方法之間對應的關係與調用的時機。那麼如今咱們一塊兒來分析谷歌對整個嵌套滑動過程的實現與設計。爲了處理嵌套滑動，谷歌將整個過程分爲了如下幾個步驟：
- 1.當父控件不攔截事件，子控件收到滑動事件後，會先詢問父控件是否支持嵌套滑動。
- 2.若是父控件支持嵌套滑動，那麼父控件進行預先滑動。而後將處理剩餘的距離交由給子控件處理。
- 3.子控件收到父控件剩餘的滑動距離並滑動結束後，若是滑動距離還有剩餘，又會再問一下父控件是否須要再繼續消耗剩下的距離。
- 4.若是子控件產生了fling，會先詢問父控件是否
預先攔截fling。若是父控件預先攔截。則交由給父控件處理。子控件則不處理fling。 - 5.若是父控件不預先攔截fling, 那麼會將fling傳給父控件處理。同時子控件也會處理fling。
- 6.當整個嵌套滑動結束時，子控件通知父控件嵌套滑動結束。
對fling效果不熟悉的小夥伴能夠查看該篇文章---RecyclerView之Scroll和Fling
再結合以前咱們對NestedScrollingParent與NestedScrollingChild中的方法。咱們能夠獲得相應方法之間的調用關係。具體以下圖所示：
子控件方法調用時機
當咱們瞭解了接口的調用關係後，咱們須要知道子控件對相應嵌套滑動方法的調用時機。由於在低版本下，子控件向父控件傳遞事件須要配合NestedScrollingChildHelper類與NestedScrollingChild接口一塊兒使用。因爲篇幅的限制。這裏就不向你們介紹如何構造一個支持嵌套滑動的子控件了。在接下來的知識點中都會在NestedScrollingChildView 的基礎上進行講解。但願你們能夠結合代碼與博客一塊兒理解。
在接下來的章節中，會先講解谷歌在NestedScrollingParent與NestedScrollingChild接口下嵌套滑動的API設計。關於NestedScrollingParent2與NestedScrollingChild2接口會單獨進行解釋。
子控件startNestedScroll方法調用時機
根據嵌套滑動的機制設定，子控件若是想要將事件傳遞給父控件，那麼父控件是不能攔截事件的。當子控件想要將事件交給父控件進行預處理，那麼必然會在其onTouchEvent方法，將事件傳遞給父控件。須要注意的是當子控件調用startNestedScroll方法時，只是判斷是否有支持嵌套滑動的父控件，並通知父控件嵌套滑動開始。這個時候並無真正的傳遞相應的事件。故該方法只能在子控件的onTouchEvent方法中事件爲MotionEvent.ACTION_DOWN時調用。僞代碼以下所示：
public boolean onTouchEvent(MotionEvent event) {
int action = event.getActionMasked();
switch (action) {
case MotionEvent.ACTION_DOWN: {
mLastX = x;
mLastY = y;
//查找嵌套滑動的父控件，並通知父控件嵌套滑動開始。這裏默認是設置的豎直方向
startNestedScroll(ViewCompat.SCROLL_AXIS_VERTICAL);
break;
}
}
return super.onTouchEvent(event);
}
複製代碼
那子view僅僅經過startNestedScroll方法是如何找到父控件並通知父控件嵌套滑動開始的呢？咱們來看看startNestedScroll方法的具體實現，startNestedScroll方法內部會調用NestedScrollingChildHelper的startNestedScroll方法。具體代碼以下所示：
public boolean startNestedScroll(@ScrollAxis int axes, @NestedScrollType int type) {
if (hasNestedScrollingParent(type)) {
// Already in progress
return true;
}
if (isNestedScrollingEnabled()) {//判斷子控件是否支持嵌套滑動
//獲取當前的view的父控件
ViewParent p = mView.getParent();
View child = mView;
while (p != null) {
//判斷當前父控件是否支持嵌套滑動
if (ViewParentCompat.onStartNestedScroll(p, child, mView, axes, type)) {
setNestedScrollingParentForType(type, p);
ViewParentCompat.onNestedScrollAccepted(p, child, mView, axes, type);
return true;
}
if (p instanceof View) {
child = (View) p;
}
//繼續向上尋找
p = p.getParent();
}
}
return false;
}
複製代碼
從代碼中咱們能夠看出，當子控件支持嵌套滑動時，子控件會獲取當前父控件，並調用ViewParentCompat.onStartNestedScroll方法。咱們繼續查看該方法:
public static boolean onStartNestedScroll(ViewParent parent, View child, View target, int nestedScrollAxes, int type) {
if (parent instanceof NestedScrollingParent2) {//判斷父控件是否實現NestedScrollingParent2
// First try the NestedScrollingParent2 API
return ((NestedScrollingParent2) parent).onStartNestedScroll(child, target,
nestedScrollAxes, type);
} else if (type == ViewCompat.TYPE_TOUCH) {//若是父控件實現NestedScrollingParent
// Else if the type is the default (touch), try the NestedScrollingParent API
return IMPL.onStartNestedScroll(parent, child, target, nestedScrollAxes);
}
return false;
}
複製代碼
觀察代碼，咱們能夠發現，當父控件實現NestedScrollingParent接口後，會走IMPL.onStartNestedScroll方法，咱們繼續跟下去：
public boolean onStartNestedScroll(ViewParent parent, View child, View target, int nestedScrollAxes) {
if (parent instanceof NestedScrollingParent) {
return ((NestedScrollingParent) parent).onStartNestedScroll(child, target,
nestedScrollAxes);
}
return false;
}
複製代碼
最後會調用ViewParetCompat中的onStartNestedScroll方法，該方法最終會調用父控件的onStartNestedScroll方法。繞了一大圈，也就調用了父控件的onStartNestedScroll來判斷是否支持嵌套滑動。
那如今咱們再回到子控件的startNestedScroll方法中。咱們能夠得知，若是當前父控件不支持嵌套滑動，那麼會一直向上尋找，直到找到爲止。若是仍然沒有找到，那麼接下來的子父控件的嵌套滑動方法都不會調用。若是子控件找到了支持嵌套滑動的父控件，那麼接下來會調用父控件的onNestedScrollAccepted方法，表示父控件接受嵌套滑動。
子控件dispatchNestedPreScroll方法調用時機
當父控件接受嵌套滑動後，那麼子控件須要將手勢滑動傳遞給父控件，由於這裏已經產生了滑動，故會在onTouchEvent中篩選MotionEvent.ACTION_MOVE中的事件，而後調用dispatchNestedPreScroll方法這些將滑動事件傳遞給父控件。僞代碼以下所示：
private final int[] mScrollConsumed = new int[2];//記錄父控件消耗的距離
public boolean onTouchEvent(MotionEvent event) {
int action = event.getActionMasked();
switch (action) {
case MotionEvent.ACTION_MOVE: {
int dy = mLastY - y;
int dx = mLastX - x;
//將事件傳遞給父控件，並記錄父控件消耗的距離。
if (dispatchNestedPreScroll(dx, dy, mScrollConsumed, mScrollOffset)) {
dx -= mScrollConsumed[0];
dy -= mScrollConsumed[1];
}
}
}
return super.onTouchEvent(event);
}
複製代碼
在上述代碼中，dy與dx分別爲子控件豎直與水平方向上的距離，int[] mScrollConsumed豎直用於記錄父控件消耗的距離。那麼當咱們調用dispatchNestedPreScroll的方法，將事件傳遞給父控件進行消耗時，那麼子控件實際能處理的距離爲：
- 水平方向： dx -= mScrollConsumed[0];
- 豎直方向： dy -= mScrollConsumed[1];
接下來，咱們繼續查看dispatchNestedPreScroll的方法。
在dispatchNestedPreScroll方法內部會調用NestedScrollingChildHelper的dispatchNestedPreScroll方法具體代碼以下：
public boolean dispatchNestedPreScroll(int dx, int dy, @Nullable int[] consumed, @Nullable int[] offsetInWindow, @NestedScrollType int type) {
if (isNestedScrollingEnabled()) {
//獲取當前嵌套滑動的父控件，若是爲null，直接返回
final ViewParent parent = getNestedScrollingParentForType(type);
if (parent == null) {
return false;
}
if (dx != 0 || dy != 0) {
int startX = 0;
int startY = 0;
if (offsetInWindow != null) {
mView.getLocationInWindow(offsetInWindow);
startX = offsetInWindow[0];
startY = offsetInWindow[1];
}
if (consumed == null) {
if (mTempNestedScrollConsumed == null) {
mTempNestedScrollConsumed = new int[2];
}
consumed = mTempNestedScrollConsumed;
}
consumed[0] = 0;
consumed[1] = 0;
//調用父控件的onNestedPreScroll處理事件
ViewParentCompat.onNestedPreScroll(parent, mView, dx, dy, consumed, type);
if (offsetInWindow != null) {
mView.getLocationInWindow(offsetInWindow);
offsetInWindow[0] -= startX;
offsetInWindow[1] -= startY;
}
return consumed[0] != 0 || consumed[1] != 0;
} else if (offsetInWindow != null) {
offsetInWindow[0] = 0;
offsetInWindow[1] = 0;
}
}
return false;
}
複製代碼
在該方法中，會先判斷獲取當前嵌套滑動的父控件。若是父控件不爲null且支持嵌套滑動，那麼接下來會調用ViewParentCompat.onNestedPreScroll（）方法。代碼以下所示：
public void onNestedPreScroll(ViewParent parent, View target, int dx, int dy, int[] consumed) {
if (parent instanceof NestedScrollingParent) {
((NestedScrollingParent) parent).onNestedPreScroll(target, dx, dy, consumed);
}
}
複製代碼
觀察代碼最終會調用父控件的onNestedPreScroll方法。須要注意的是，父控件可能會將子控件傳遞的滑動事件所有消耗。那麼子控件就沒有繼續可處理的事件了。
onNestedPreScroll方法在嵌套滑動時判斷父控件的滑動距離時尤其重要。
子控件dispatchNestedScroll方法調用時機
當父控件預先處理滑動事件後，也就是調用onNestedPreScroll方法並把消耗的距離傳遞給子控件後，子控件會獲取剩下的事件並消耗。若是子控件仍然沒有消耗完，那麼會調用dispatchNestedScroll將剩下的事件傳遞給父控件。若是父控件不處理。那麼又會傳遞給子控件進行處理。僞代碼以下所示：
private final int[] mScrollConsumed = new int[2];//記錄父控件消耗的距離
public boolean onTouchEvent(MotionEvent event) {
int action = event.getActionMasked();
switch (action) {
case MotionEvent.ACTION_MOVE: {
int dy = mLastY - y;
int dx = mLastX - x;
//將事件傳遞給父控件，並記錄父控件消耗的距離。
if (dispatchNestedPreScroll(dx, dy, mScrollConsumed, mScrollOffset)) {
dx -= mScrollConsumed[0];
dy -= mScrollConsumed[1];
scrollNested(dx,dy);//處理嵌套滑動
}
}
}
return super.onTouchEvent(event);
}
//處理嵌套滑動
private void scrollNested(int x, int y) {
int unConsumedX = 0, unConsumedY = 0;
int consumedX = 0, consumedY = 0;
//子控件消耗多少事件，由本身決定
if (x != 0) {
consumedX = childConsumeX(x);
unConsumedX = x - consumedX;
}
if (y != 0) {
consumedY = childConsumeY(y);
unConsumedY = y - consumedY;
}
//子控件處理事件
childScroll(consumedX, consumedY);
//子控件處理後，又將剩下的事件傳遞給父控件
if (dispatchNestedScroll(consumedX, consumedY, unConsumedX, unConsumedY, mScrollOffset)) {
//傳給父控件處理後，剩下的邏輯本身實現
}
//傳遞給父控件，父控件不處理，那麼子控件就繼續處理。
childScroll(unConsumedX, unConsumedY);
}
/** * 子控件滑動邏輯 */
private void childScroll(int x, int y) {
//子控件怎麼滑動，本身實現
}
/** * 子控件水平方向消耗多少距離 */
private int childConsumeX(int x) {
//具體邏輯由本身實現
return 0;
}
/** * 子控件豎直方向消耗距離 */
private int childConsumeY(int y) {
//具體邏輯由本身實現
return 0;
}
複製代碼
在上述代碼中，由於子控件消耗多少距離，是由子控件進行決定的，因此將這些方法抽象了出來了。在子控件的dispatchNestedScroll方法內部會調用NestedScrollingChildHelper的dispatchNestedScroll方法，具體代碼以下所示：
public boolean dispatchNestedScroll(int dxConsumed, int dyConsumed, int dxUnconsumed, int dyUnconsumed, @Nullable int[] offsetInWindow, @NestedScrollType int type) {
if (isNestedScrollingEnabled()) {
final ViewParent parent = getNestedScrollingParentForType(type);
if (parent == null) {
return false;
}
if (dxConsumed != 0 || dyConsumed != 0 || dxUnconsumed != 0 || dyUnconsumed != 0) {
int startX = 0;
int startY = 0;
if (offsetInWindow != null) {
mView.getLocationInWindow(offsetInWindow);
startX = offsetInWindow[0];
startY = offsetInWindow[1];
}
//調用父控件的onNestedScroll方法。
ViewParentCompat.onNestedScroll(parent, mView, dxConsumed,
dyConsumed, dxUnconsumed, dyUnconsumed, type);
if (offsetInWindow != null) {
mView.getLocationInWindow(offsetInWindow);
offsetInWindow[0] -= startX;
offsetInWindow[1] -= startY;
}
return true;
} else if (offsetInWindow != null) {
// No motion, no dispatch. Keep offsetInWindow up to date.
offsetInWindow[0] = 0;
offsetInWindow[1] = 0;
}
}
return false;
}
複製代碼
該方法內部會調用ViewParentCompat.onNestedScroll方法。繼續跟蹤最終會調用ViewParentCompat中非靜態的的onNestedScroll方法，代碼以下所示：
public void onNestedScroll(ViewParent parent, View target, int dxConsumed, int dyConsumed, int dxUnconsumed, int dyUnconsumed) {
if (parent instanceof NestedScrollingParent) {
((NestedScrollingParent) parent).onNestedScroll(target, dxConsumed, dyConsumed,
dxUnconsumed, dyUnconsumed);
}
}
複製代碼
該方法中，最終會調用父控件的onNestedScroll方法來處理子控件剩餘的距離。
子控件stopNestedScroll方法調用時機
當整個事件序列結束的時候(當手指擡起或取消滑動的時候)，須要通知父控件嵌套滑動已經結束。故咱們須要在OnTouchEvent中篩選MotionEvent.ACTION_UP、MotionEvent.ACTION_CANCEL中的事件，並經過stopNestedScroll（）方法通知父控件。僞代碼以下所示：
public boolean onTouchEvent(MotionEvent event) {
int action = event.getActionMasked();
switch (action) {
case MotionEvent.ACTION_UP: { //當手指擡起的時，結束事件傳遞
stopNestedScroll();
break;
}
case MotionEvent.ACTION_CANCEL: { //當手指擡起的時，結束事件傳遞
stopNestedScroll();
break;
}
}
return super.onTouchEvent(event);
}
複製代碼
在stopNestedScroll（）方法中，最終會調用父控件的onStopNestedScroll（）方法，這裏就不作更多的分析了。
子控件fling分發時機
如今就剩下最後一個嵌套滑動的方法了！！！對！就是fling。在瞭解子控件對fling的處理過程以前，咱們先要知道fling表明什麼樣的效果。在Android系統下，手指在屏幕上滑動而後鬆手，控件中的內容會順着慣性繼續往手指滑動的方向繼續滾動直到中止，這個過程叫作fling。也就是咱們須要在onTouchEvent方法中篩選MotionEvent.ACTION_UP的事件並獲取須要的滑動速度。僞代碼以下：
fling的中文意思爲拋、扔、擲。
public boolean onTouchEvent(MotionEvent event) {
//添加速度檢測器，用於處理fling
if (mVelocityTracker == null) {
mVelocityTracker = VelocityTracker.obtain();
}
mVelocityTracker.addMovement(event);
int action = event.getActionMasked();
switch (action) {
case MotionEvent.ACTION_UP: {
mVelocityTracker.computeCurrentVelocity(1000, mMaxFlingVelocity);
int xvel = (int) mVelocityTracker.getXVelocity();
int yvel = (int) mVelocityTracker.getYVelocity();
if (!dispatchNestedPreFling(velocityX, velocityY)) {
boolean consumed = canScroll();
//將fling效果傳遞給父控件
dispatchNestedFling(velocityX, velocityY, consumed);
//而後子控件再處理fling
childFling();//子控件本身實現怎麼處理fling
stopNestedScroll();//子控件通知父控件滾動結束
}
stopNestedScroll();//通知父控件結束滑動
break;
}
}
return super.onTouchEvent(event);
}
複製代碼
這裏就不在對fling效果是怎麼分發到父控件進行解釋啦~~。必定要結合NestedScrollingChildView類進行理解。那麼假設你們都看了源碼，那麼咱們能夠獲得以下幾點：
- 子控件dispatchNestedPreFling最終會調用父控件的onNestedPreFling方法。
- 子控件的dispatchNestedFling最終會調用onNestedFling方法。
- 若是父控件的攔截fling(也就是onNestedPreFling方法返回爲
true)。那麼子控件是沒有機會處理fling的。 - 若是父控件
不攔截fling(也就是onNestedPreFling方法返回爲false)，則父控件會調用onNestedFling方法與子控件同時處理fling。 - 當父控件與子控件同時處理fling時，子控件會當即調用stopNestedScroll方法通知父控件嵌套滑動結束。
NestedScrollingChild2與NestedScrollingParent2簡介
最後一個知識點了，你們加油啊!!!!!!
在本文章前半部，咱們都是圍繞NestedScrollingChild與NestedScrollingParent進行講解。並無說起NestedScrollingChild2與NestedScrollingParent2接口。那這兩個接口是處理什麼的呢？這又要回到上文咱們提到的NestedScrollingChild處理fling時的流程了，在谷歌以前的NestedScrollingParent與NestedScrollingChild的API設計中。並無考慮以下問題：
- 父控件根本不可能知道子控件是否fling結束。子控件只是在
ACTION_UP中調用了stopNestedScroll方法。雖然通知了父控件結束嵌套滑動，可是子控件仍然可能處於fling中。 - 子控件沒有辦法將部分fling傳遞給父控件。父控件必須處理整個fling。
而使用NestedScrollingChild2與NestedScrollingParent2這兩個接口，子控件就能將fling傳遞給父控件，而且父控件處理了部分fling後，又能夠將剩餘的fling再傳遞給子控件。當子控件中止fling時，通知父控件fling結束了。這和咱們以前分析的嵌套滑動是否是很像呢？直接講知識點，你們不是很好理解，看下面這個例子：
上述效果實現，請參看NestedScrollingParentLayout.java
在上面例子中是實現了NestedScrollingChild(NestedScrollView或RecyclerView等)與NestedScrollingParent接口的嵌套滑動，咱們能夠明顯的看出，當咱們手指快速向下滑動並擡起的時，子控件將fling分發給父控件，由於處理的距離不一樣，這個時候父控件已經處理滑動並fling結束，而內部的子控件(RecyclerView或NestedScrollView還在滾動，這種給咱們的感受就很是不連貫，好像每一個控件在獨自滑動。
在一樣的滑動條件下，實現了NestedScrollingChild2(NestedScrollView或RecyclerView等)與NestedScrollingParent2接口的嵌套滑動.看下面的例子：
上述效果實現，請參看NestedScrollingParent2Layout.java
觀察上圖，咱們能發現父控件與子控件(RecyclerView或NestedScrollView)的滑動更爲順暢與合理。那接下來咱們看看谷歌對其的設計。
NestedScrollingChild2與NestedScrollingParent2分別繼承了NestedScrollingChild與NestedScrollingParent，在繼承的接口部分方法上增長了type參數。其中type的取值爲TYPE_TOUCH(0)、TYPE_NON_TOUCH(1)。用於區分手勢滑動與fling。具體差別以下圖所示：
圖片較大，可能閱讀不清晰，建議放大觀看。
谷歌在fling的處理上也與以前的NestedScrollingChild與NestedScrollingParent有所差別，在onTouchEvent方法中的邏輯進行了修改，僞代碼以下所示：
@Override
public boolean onTouchEvent(MotionEvent event) {
int action = event.getActionMasked();
int y = (int) event.getY();
int x = (int) event.getX();
//添加速度檢測器，用於處理fling效果
if (mVelocityTracker == null) {
mVelocityTracker = VelocityTracker.obtain();
}
mVelocityTracker.addMovement(event);
switch (action) {
case MotionEvent.ACTION_UP: {//當手指擡起的時，結束嵌套滑動傳遞,並判斷是否產生了fling效果
mVelocityTracker.computeCurrentVelocity(1000, mMaxFlingVelocity);
int xvel = (int) mVelocityTracker.getXVelocity();
int yvel = (int) mVelocityTracker.getYVelocity();
fling(xvel, yvel);//具體處理fling的方法
mVelocityTracker.clear();
stopNestedScroll(ViewCompat.TYPE_TOUCH));//注意這裏stop的是帶了參數的
break;
}
}
return super.onTouchEvent(event);
}
複製代碼
當子控件手指擡起的時候，咱們發現是調用stopNestedScroll(ViewCompat.TYPE_TOUCH)的方式來通知父控件當前手勢滑動已經結束，繼續查看fling方法。僞代碼以下所示：
private boolean fling(int velocityX, int velocityY) {
//判斷速度是否足夠大。若是夠大才執行fling
if (Math.abs(velocityX) < mMinFlingVelocity) {
velocityX = 0;
}
if (Math.abs(velocityY) < mMinFlingVelocity) {
velocityY = 0;
}
if (velocityX == 0 && velocityY == 0) {
return false;
}
if (dispatchNestedPreFling(velocityX, velocityY)) {
boolean canScroll = canScroll();
//將fling效果傳遞給父控件
dispatchNestedFling(velocityX, velocityY, canScroll);
//子控件在處理fling效果
if (canScroll) {
//通知父控件開始fling事件，
startNestedScroll(ViewCompat.SCROLL_AXIS_VERTICAL, ViewCompat.TYPE_NON_TOUCH);
velocityX = Math.max(-mMaxFlingVelocity, Math.min(velocityX, mMaxFlingVelocity));
velocityY = Math.max(-mMaxFlingVelocity, Math.min(velocityY, mMaxFlingVelocity));
doFling(velocityX, velocityY);
return true;
}
}
return false;
}
複製代碼
從代碼中，咱們能夠看見，在新接口的處理邏輯中，仍是會調用dispatchNestedPreFling與dispatchNestedFling方法。也就是以前的處理fling方式是沒有被替代的，可是這並不說明沒有變化。咱們發現子控件調用了startNestedScroll方法，並設置了當前類型爲TYPE_NON_TOUCH（fling),那麼也就是說，在實現了NestedScrollingParent2的父控件中，咱們能夠在onStartNestedScroll方法中知道當前的滑動類型究竟是fling，仍是手勢滑動。咱們繼續查看doFling方法。僞代碼以下：
/** * 實際的fling處理效果 */
private void doFling(int velocityX, int velocityY) {
mScroller.fling(0, 0, velocityX, velocityY, Integer.MIN_VALUE, Integer.MAX_VALUE, Integer.MIN_VALUE, Integer.MAX_VALUE);
postInvalidate();
}
複製代碼
doFling方法其實很簡單，就是調用OverScroller的fing方法，並調用postInvalidate方法(爲了幫助你們理解，這裏並無採用 postOnAnimation()的方式)。其中OverScroller的fing方法主要是根據當前傳入的速度，計算出在勻減速狀況下,實際運動的距離。這裏也就解釋了爲何，在只有速度的狀況下，子控件能夠將fling傳遞給父控件，由於速度最後變成了實際的運動距離。
這裏就不對Scroller的fling方法中如何將速度轉換成距離的算法進行講解了。不熟悉的小夥伴能夠自行谷歌或百度。
熟悉Scroller的小夥伴必定知道，爲了獲取到fling所產生的距離，咱們須要調用postInvalidate()方法或Invalidate()方法。同時在子控件的computeScroll()方法中獲取實際的運動距離。那麼也就說最終的子控件的fing的分發實際是在computeScroll()方法中。繼續查看該方法的僞代碼：
public void computeScroll() {
if (mScroller.computeScrollOffset()) {
int x = mScroller.getCurrX();
int y = mScroller.getCurrY();
int dx = x - mLastFlingX;
int dy = y - mLastFlingY;
mLastFlingX = x;
mLastFlingY = y;
//在子控件處理fling以前，先判斷父控件是否消耗
if (dispatchNestedPreScroll(dx, dy, mScrollConsumed, null, TYPE_NON_TOUCH)) {
//計算父控件消耗後，剩下的距離
dx -= mScrollConsumed[0];
dy -= mScrollConsumed[1];
//由於以前默認向父控件傳遞的豎直方向，因此這裏子控件也消耗剩下的豎直方向
int hResult = 0;
int vResult = 0;
int leaveDx = 0;//子控件水平fling 消耗的距離
int leaveDy = 0;//父控件豎直fling 消耗的距離
if (dx != 0) {
leaveDx = childFlingX(dx);
hResult = dx - leaveDx;//獲得子控件消耗後剩下的水平距離
}
if (dy != 0) {
leaveDy = childFlingY(dy);//獲得子控件消耗後剩下的豎直距離
vResult = dy - leaveDy;
}
dispatchNestedScroll(leaveDx, leaveDy, hResult, vResult, null, TYPE_NON_TOUCH);
}
} else {
//當fling 結束時，通知父控件
stopNestedScroll(TYPE_NON_TOUCH);
}
}
複製代碼
觀察代碼，咱們能夠發現，子控件中分發fling的方式在與以前分發手勢滾動的邏輯很是一致。
- 產生fing時，調用帶
type(TYPE_NON_TOUCH)參數的dispatchNestedPreScroll方法，判斷父控件是否處理fling事件。 - 若是父控件處理，那麼父控件消耗後，子控件再消耗剩餘的距離
- 子控件消耗後，若是還有剩餘的距離，則調用帶
type(TYPE_NON_TOUCH)參數的dispatchNestedScroll方法，將剩下的距離傳遞給父控件。 - 當子控件fling結束時，則調用stopNestedScroll(TYPE_NON_TOUCH)方法，通知父控件fling已經結束。
那麼也就是說，NestedScrollingChild2與NestedScrollingParent2接口，只是在原有的方法中增長了TYPE_NON_TOUCH參數來讓父控件區分究竟是手勢滑動仍是fling。不得不佩服谷歌大佬的設計。不只兼容還解決了實際的問題。
總結
經過上文的分析，咱們能獲得以下結論：
- NestedScrolling(嵌套滑動)機制是創建在原有的事件機制之上，要實現嵌套滑動，父控件是不能攔截事件。
- NestedScrolling(嵌套滑動)機制中接口要成對使用。如NestedScrollingChild2與NestedScrollingParent2成對。NestedScrollingChild與NestedScrollingParent成對。
- 當咱們須要子控件分發fling給父控件時，咱們須要使用NestedScrollingChild2與NestedScrollingParent2。並在相應的方法中經過type（
TYPE_TOUCH(0)、TYPE_NON_TOUCH(1)),來判斷是手勢滑動仍是fling。
最後
到如今整個NestedScrolling(嵌套滑動)機制就講解完畢了，在接下來的文章中，會講解相應嵌套滑動例子、CoordinatorLayout與Behavior、自定義Behavior等相關知識點，若是你們有興趣的話，能夠持續關注~。謝謝你們花時間閱讀文章啦。Thanks
- 1. 自定義View事件之進階篇(一)-NestedScrolling(嵌套滑動)機制
- 2. NestedScrolling機制解析，自定義嵌套滑動你也能夠
- 3. 自定義View事件篇進階篇(二)-自定義NestedScrolling實戰
- 4. Android 嵌套滑動機制（NestedScrolling）
- 5. NestedScrolling（Android嵌套滑動機制）
- 6. Android嵌套滑動機制NestedScrolling
- 7. 淺析NestedScrolling嵌套滑動機制之基礎篇
- 8. 淺析NestedScrolling嵌套滑動機制之實踐篇-自定義Behavior實現小米音樂歌手詳情
- 9. 淺析NestedScrolling嵌套滑動機制之CoordinatorLayout.Behavior
- 10. NestedScrolling 嵌套滑動機制：簡單實踐（一）
- 更多相關文章...
- • 自定義TypeHandler - MyBatis教程
- • ionic 滑動框 - ionic 教程
- • RxJava操作符（十）自定義操作符
- • 漫談MySQL的鎖機制
-
每一个你不满意的现在，都有一个你没有努力的曾经。
- 1. python的安裝和Hello，World編寫
- 2. 重磅解讀：K8s Cluster Autoscaler模塊及對應華爲雲插件Deep Dive
- 3. 鴻蒙學習筆記2（永不斷更）
- 4. static關鍵字 和構造代碼塊
- 5. JVM筆記
- 6. 無法啓動 C/C++ 語言服務器。IntelliSense 功能將被禁用。錯誤: Missing binary at c:\Users\MSI-NB\.vscode\extensions\ms-vsc
- 7. 【Hive】Hive返回碼狀態含義
- 8. Java樹形結構遞歸（以時間換空間）和非遞歸（以空間換時間）
- 9. 數據預處理---缺失值
- 10. 都要2021年了，現代C++有什麼值得我們學習的？
- 1. 自定義View事件之進階篇(一)-NestedScrolling(嵌套滑動)機制
- 2. NestedScrolling機制解析，自定義嵌套滑動你也能夠
- 3. 自定義View事件篇進階篇(二)-自定義NestedScrolling實戰
- 4. Android 嵌套滑動機制（NestedScrolling）
- 5. NestedScrolling（Android嵌套滑動機制）
- 6. Android嵌套滑動機制NestedScrolling
- 7. 淺析NestedScrolling嵌套滑動機制之基礎篇
- 8. 淺析NestedScrolling嵌套滑動機制之實踐篇-自定義Behavior實現小米音樂歌手詳情
- 9. 淺析NestedScrolling嵌套滑動機制之CoordinatorLayout.Behavior
- 10. NestedScrolling 嵌套滑動機制：簡單實踐（一）