2. 程式人生 > >Android NestedScrolling解決滑動衝突問題(1) - 相關介面

Android NestedScrolling解決滑動衝突問題(1) - 相關介面

阿新 • • 發佈：2018-12-01

Android NestedScrolling解決滑動衝突問題

當父View及子View都可以滑動，並且滑動方向一致時(例如CoordinatorLayout內嵌RecyclerView或者Webview)，滑動衝突的解決就需要依賴於Android為我們提供的NestedScrolling介面。

NestedScrolling 介面分為兩個部分：NestedScrollingParent 及 NestedScrollingChild。

為方便描述，以下簡稱NestedScrollingParent為NP, NestedScrollingChild為NC。

NestedScrollingChild

包含的介面：

public interface NestedScrollingChild {
    /**
     * 設定當前View是否啟用nested scroll特性
     * @param enabled 是否啟用
     */
    void setNestedScrollingEnabled(boolean enabled);

    /**
     * 當前View是否啟用了nested scroll特性
     * @return
     */
    boolean isNestedScrollingEnabled();

    /**
     * 在axes軸上發起nested scroll開始操作
     * @param axes 滑動方向
     * @return 是否有NestedScrollingParent接受此次滑動請求
     */
 

    boolean startNestedScroll(@ViewCompat.ScrollAxis int axes);

    /**
     * 終止nested scroll
     */
    void stopNestedScroll();

    /**
     * 當前是否有NestedScrollingParent接受了此次滑動請求
     * @return 返回值
     */
    boolean hasNestedScrollingParent();

    /**
     * nested scroll的一步滑動操作中，在自己開始滑動處理之前，分配預處理操作（一般為詢問NestedScrollingParent是否消耗部分滑動距離）
     * @param dx 當前這一步滑動的x軸總距離
     * @param dy 當前這一步滑動的y軸總距離
     * @param consumed 預處理操作消耗掉的距離（此為輸出引數，consumed[0]為預處理操作消耗掉的x軸距離，consumed[1]為預處理操作消耗掉的y軸距離）
     * @param offsetInWindow 可選引數，可以為null。為輸出引數，獲取預處理操作使當前view的位置偏移(offsetInWindow[0]和offsetInWindow[1]分別為x軸和y軸偏移)
     * @return 預處理操作是否消耗了部分或者全部滑動距離
     */
 

    boolean dispatchNestedPreScroll(int dx, int dy, @Nullable int[] consumed,
                                    @Nullable int[] offsetInWindow);

    /**
     * 在當前View處理了滑動之後繼續分配滑動操作 (一般在自己處理滑動之後，給NestedScrollingParent機會處理剩餘的滑動距離)
     * @param dxConsumed 已經消耗了的x軸滑動距離
     * @param dyConsumed 已經消耗了的y軸滑動距離
     * @param dxUnconsumed 未消耗的x軸滑動距離
     * @param dyUnconsumed 未消耗的y軸滑動距離
     * @param offsetInWindow 可選引數，可以為null。為輸出引數，獲取預處理操作使當前view的位置偏移(offsetInWindow[0]和offsetInWindow[1]分別為x軸和y軸偏移)
     * @return
     */
    boolean dispatchNestedScroll(int dxConsumed, int dyConsumed,
                                 int dxUnconsumed, int dyUnconsumed, @Nullable int[] offsetInWindow);

    /**
     * 在當前NestedScrollingChild處理fling事件之前進行預處理(一般詢問NestedScrollingParent是否處理消耗此次fling)
     * @param velocityX x軸速度
     * @param velocityY y軸速度
     * @return 預處理是否處理消耗了此次fling
     */
    boolean dispatchNestedPreFling(float velocityX, float velocityY);

    /**
     * 分配fling操作
     * @param velocityX x軸方向速度
     * @param velocityY y軸方向速度
     * @param consumed 當前NestedScrollingChild是否處理了此次fling
     * @return NestedScrollingParent是否處理了此次fling
     */
    boolean dispatchNestedFling(float velocityX, float velocityY, boolean consumed);
}

NC是NP的子孫(並非一定是直接子View)，也是聯合滑動的請求方，滑動產生的一系列MotionEvent是在此View中跟蹤處理的，一般此View是在 onTouchEvent 中依據對 MotionEvent 的跟蹤分析來發起滑動請求。例如以下 RecyclerView 中 onTouchEvent 的簡化版本：

@Override
public boolean onTouchEvent(MotionEvent e) {
    final boolean canScrollHorizontally = mLayout.canScrollHorizontally();
    final boolean canScrollVertically = mLayout.canScrollVertically();

    if (mVelocityTracker == null) {
        mVelocityTracker = VelocityTracker.obtain();
    }
    boolean eventAddedToVelocityTracker = false;

    final MotionEvent vtev = MotionEvent.obtain(e);
    final int action = e.getActionMasked();
    final int actionIndex = e.getActionIndex();

    if (action == MotionEvent.ACTION_DOWN) {
        mNestedOffsets[0] = mNestedOffsets[1] = 0;
    }
    vtev.offsetLocation(mNestedOffsets[0], mNestedOffsets[1]);

    switch (action) {
        case MotionEvent.ACTION_DOWN: {
            mScrollPointerId = e.getPointerId(0);
            mInitialTouchX = mLastTouchX = (int) (e.getX() + 0.5f);
            mInitialTouchY = mLastTouchY = (int) (e.getY() + 0.5f);

            int nestedScrollAxis = ViewCompat.SCROLL_AXIS_NONE;
            if (canScrollHorizontally) {
                nestedScrollAxis |= ViewCompat.SCROLL_AXIS_HORIZONTAL;
            }
            if (canScrollVertically) {
                nestedScrollAxis |= ViewCompat.SCROLL_AXIS_VERTICAL;
            }
            // 發起滾動請求
            startNestedScroll(nestedScrollAxis, TYPE_TOUCH);
        } break;

        case MotionEvent.ACTION_MOVE: {
            final int x = (int) (e.getX(index) + 0.5f);
            final int y = (int) (e.getY(index) + 0.5f);
            int dx = mLastTouchX - x;
            int dy = mLastTouchY - y;

            // 先詢問 NP 是否需要提前消耗滑動距離(部分或者全部)
            if (dispatchNestedPreScroll(dx, dy, mScrollConsumed, mScrollOffset, TYPE_TOUCH)) {
                // NP消耗了部分滑動距離
                dx -= mScrollConsumed[0]; // NP 消耗的X軸滑動距離
                dy -= mScrollConsumed[1]; // NP消耗的Y軸滑動距離
                vtev.offsetLocation(mScrollOffset[0], mScrollOffset[1]);
                // Updated the nested offsets
                mNestedOffsets[0] += mScrollOffset[0];
                mNestedOffsets[1] += mScrollOffset[1];
            }

            //分析是否本身需要滑動及本身滑動所消耗的滑動距離
            if (mScrollState != SCROLL_STATE_DRAGGING) {
                boolean startScroll = false;
                if (canScrollHorizontally && Math.abs(dx) > mTouchSlop) {
                    if (dx > 0) {
                        dx -= mTouchSlop;
                    } else {
                        dx += mTouchSlop;
                    }
                    startScroll = true;
                }
                if (canScrollVertically && Math.abs(dy) > mTouchSlop) {
                    if (dy > 0) {
                        dy -= mTouchSlop;
                    } else {
                        dy += mTouchSlop;
                    }
                    startScroll = true;
                }
                if (startScroll) {
                    setScrollState(SCROLL_STATE_DRAGGING);
                }
            }

            if (mScrollState == SCROLL_STATE_DRAGGING) {
                mLastTouchX = x - mScrollOffset[0];
                mLastTouchY = y - mScrollOffset[1];

                // 自己內部滑動
                if (scrollByInternal(
                        canScrollHorizontally ? dx : 0,
                        canScrollVertically ? dy : 0,
                        vtev)) {
                    getParent().requestDisallowInterceptTouchEvent(true);
                }
                if (mGapWorker != null && (dx != 0 || dy != 0)) {
                    mGapWorker.postFromTraversal(this, dx, dy);
                }
            }
        } break;

        case MotionEvent.ACTION_POINTER_UP: {
            onPointerUp(e);
        } break;

        case MotionEvent.ACTION_UP: {
            mVelocityTracker.addMovement(vtev);
            eventAddedToVelocityTracker = true;
            mVelocityTracker.computeCurrentVelocity(1000, mMaxFlingVelocity);
            final float xvel = canScrollHorizontally
                    ? -mVelocityTracker.getXVelocity(mScrollPointerId) : 0;
            final float yvel = canScrollVertically
                    ? -mVelocityTracker.getYVelocity(mScrollPointerId) : 0;
            // 分析是否產生fling事件(手機快速滑動之後擡起，檢視繼續滑動) 
            if (!((xvel != 0 || yvel != 0) && fling((int) xvel, (int) yvel))) {
                setScrollState(SCROLL_STATE_IDLE);
            }
            resetTouch();
        } break;

        case MotionEvent.ACTION_CANCEL: {
            cancelTouch();
        } break;
    }

    if (!eventAddedToVelocityTracker) {
        mVelocityTracker.addMovement(vtev);
    }
    vtev.recycle();

    return true;
}

及 scrollByInternal簡化版：

boolean scrollByInternal(int x, int y, MotionEvent ev) {
    int unconsumedX = 0, unconsumedY = 0;
    int consumedX = 0, consumedY = 0;

    if (mAdapter != null) {
        if (x != 0) {
            // 自己滑動消耗的X軸滑動距離
            consumedX = mLayout.scrollHorizontallyBy(x, mRecycler, mState);
            //尚未消耗的X軸滑動距離
            unconsumedX = x - consumedX;
        }
        if (y != 0) {
            // 自己滑動消耗的Y軸滑動距離
            consumedY = mLayout.scrollVerticallyBy(y, mRecycler, mState);
            //尚未消耗的Y軸滑動距離
            unconsumedY = y - consumedY;
        }
    }

    // 通知 NP 繼續消耗剩餘的滑動距離
    if (dispatchNestedScroll(consumedX, consumedY, unconsumedX, unconsumedY, mScrollOffset,
            TYPE_TOUCH)) {
        // Update the last touch co-ords, taking any scroll offset into account
        mLastTouchX -= mScrollOffset[0];
        mLastTouchY -= mScrollOffset[1];
        if (ev != null) {
            ev.offsetLocation(mScrollOffset[0], mScrollOffset[1]);
        }
        mNestedOffsets[0] += mScrollOffset[0];
        mNestedOffsets[1] += mScrollOffset[1];
    } 
    
    // 滑動距離是否已經完全消耗
    return consumedX != 0 || consumedY != 0;
}

所以針對一次滑動操作，NC的介面呼叫順序為：

startNestedScroll -> dispatchNestedPreScroll -> dispatchNestedScroll -> stopNestedScroll

一般性的處理邏輯可以用以下虛擬碼總結：

    private int mLastX;
    private int mLastY;
    private int[] mConsumed = new int[2];
    private int[] mOffsetInWindow = new int[2];
    @Override
    void onTouchEvent(MotionEvent event) {
        int eventX = (int) event.getRawX();
        int eventY = (int) event.getRawY();
        int action = event.getAction();
        int deltaX = eventX - mLastX;
        int deltaY = eventY - mLastY;
        switch (action) {
            case MotionEvent.ACTION_DOWN:
                int nestedScrollAxis = ViewCompat.SCROLL_AXIS_NONE;
                if (canScrollHorizontally()) {
                    nestedScrollAxis |= ViewCompat.SCROLL_AXIS_HORIZONTAL;
                }
                if (canScrollVertically()) {
                    nestedScrollAxis |= ViewCompat.SCROLL_AXIS_VERTICAL;
                }
                startNestedScroll(nestedScrollAxis);
                break;
            case MotionEvent.ACTION_MOVE:
                if (dispatchNestedPreScroll(deltaX, deltaY, mConsumed, mOffsetInWindow)) {
                    deltaX -= mConsumed[0];
                    deltaY -= mConsumed[1];
                }
                int internalScrolledX = internalScrollByX(deltaX);
                int internalScrolledY = internalScrollByY(deltaY);
                deltaX -= internalScrolledX;
                deltaY -= internalScrolledY;
                if (deltaX != 0 || deltaY != 0) {
                    dispatchNestedScroll(mConsumed[0] + internalScrolledX, mConsumed[1] + internalScrolledY, deltaX, deltaY, mOffsetInWindow);
                }
                break;
            case MotionEvent.ACTION_CANCEL:
            case MotionEvent.ACTION_UP:
                stopNestedScroll();
                break;
        }
        mLastX = eventX;
        mLastY = eventY;
    }

    /**
     * X軸方向滑動
     * @param deltaX 滑動距離
     * @return 消耗的滑動距離
     */
    abstract int internalScrollByX(int deltaX);

    /**
     * Y軸方向滑動
     * @param deltaY 滑動距離
     * @return 消耗的滑動距離
     */
    abstract int internalScrollByY(int deltaY);

    /**
     * 是否支援橫向滑動
     * @return 是否支援
     */
    abstract boolean canScrollHorizontally();

    /**
     * 是否支援豎向滑動
     * @return 是否支援
     */
    abstract boolean canScrollVertically();

NestedScrollingParent

包含介面：


public interface NestedScrollingParent {

    /**
     * 對NP子孫開始滑動請求的迴應(NestedScrollingChild.startNestedScroll)
     * @param child 包含發起請求的NP子孫view的直接子view
     * @param target 發起請求的NP子孫view
     * @param axes 滑動方向
     * @return 是否響應此滑動事件
     */
    boolean onStartNestedScroll(@NonNull View child, @NonNull View target, @ViewCompat.ScrollAxis int axes);

    /**
     * 對開始滑動響應的回撥(onStartNestedScroll返回true之後會有此回撥產生),使NestedScrollingParent有做滑動初始化工作的時機
     * @param child 包含發起請求的NP子孫view的直接子view
     * @param target 發起請求的NP子孫view
     * @param axes 滑動方向
     */
    void onNestedScrollAccepted(@NonNull View child, @NonNull View target, @ViewCompat.ScrollAxis int axes);

    /**
     * 終止nested scroll的回撥(NestedScrollingChild呼叫stopNestedScroll)
     * @param target 發起請求的NP子孫view
     */
    void onStopNestedScroll(@NonNull View target);

    /**
     * 在NestedScrollingChild處理滑動之前，預處理此滑動
     * @param target 發起請求的NP子孫view
     * @param dx x軸滑動距離
     * @param dy y軸滑動距離
     * @param consumed 回填引數，填入此次預處理消耗掉的滑動距離
     */
    void onNestedPreScroll(@NonNull View target, int dx, int dy, @NonNull int[] consumed);

    /**
     * 處理NestedScrollingChild未消耗完的滑動距離
     * @param target 發起請求的NP子孫view
     * @param dxConsumed 已消耗的x軸滑動距離
     * @param dyConsumed 已消耗的y軸滑動距離
     * @param dxUnconsumed 未消耗的x軸滑動距離
     * @param dyUnconsumed 未消耗的y軸滑動距離
     */
    void onNestedScroll(@NonNull View target, int dxConsumed, int dyConsumed,
                                 int dxUnconsumed, int dyUnconsumed);

    /**
     * 在NestedScrollingChild之前預處理fling事件
     * @param target 發起請求的NP子孫view
     * @param velocityX x軸fling速度
     * @param velocityY y軸fling速度
     * @return 是否處理此fling
     */
    boolean onNestedPreFling(@NonNull View target, float velocityX, float velocityY);

    /**
     * 處理fling事件
     * @param target 發起請求的NP子孫view
     * @param velocityX x軸fling速度
     * @param velocityY y軸fling速度
     * @param consumed NestedScrollingChild是否已處理此fling
     * @return 是否處理此fling
     */
    boolean onNestedFling(@NonNull View target, float velocityX, float velocityY, boolean consumed);


    /**
     * 獲取滑動方向
     * @return 滑動方向
     */
    @ViewCompat.ScrollAxis
    int getNestedScrollAxes();
}

介面呼叫順序

  1. NC在處理MotionEvent時，決定發起滑動請求，呼叫startNestedScroll
  2. 呼叫startNestedScroll會向上逐層遍歷父view，呼叫其onStartNestedScroll介面，如果返回true，則此view為與此次nested scroll聯動的NP並中斷遍歷；返回false則繼續向上層遍歷直到根view。如果遍歷到根view還沒找到聯動NP，則後續滑動不可用聯動。如果找到了，則進入第3步。
  3. NC呼叫NP的onNestedScrollAccepted介面。
  4. NP的onNestedScrollAccepted介面被呼叫，做一些滑動初始工作。
  5. NC探測到使用者互動產生了滑動距離，呼叫NP的onNestedPreScroll介面。
  6. NP的onNestedPreScroll介面被呼叫，預處理此次滑動，消耗部分滑動距離(或者不消耗)。
  7. NC處理剩餘的滑動距離。
  8. 如果NC沒有處理完剩下的滑動距離，則呼叫dispatchNestedScroll。
  9. NP的onNestedScroll被呼叫，自行決定是否繼續處理剩下的滑動距離。
  10. 互動上的滑動終止，NC呼叫stopNestedScroll。
  11. NP的onStopNestedScroll被呼叫。

相關推薦

Android NestedScrolling解決滑動衝突問題(1) - 相關介面

Android NestedScrolling解決滑動衝突問題 當父View及子View都可以滑動，並且滑動方向一致時(例如CoordinatorLayout內嵌RecyclerView或者Webview)，滑動衝突的解決就需要依賴於Android為我們提供的NestedScroll

Android NestedScrolling解決滑動衝突問題(2) - fling問題與NestedScroll++

滑動的處理 在前一篇文章 Android NestedScrolling解決滑動衝突問題(1) - 相關介面 中，我們分析瞭解決滑動衝突問題的 NestedScroll 介面，也給出瞭解決此類問題的一般性方案： NestedScrollingChild側 NestedScro

android ScrollView 巢狀RecyclerView 解決滑動衝突

為了解決滑動事件的衝突需要重寫ScrollView  /* * Copyright 2014 Soichiro Kashima * * Licensed under the Apache License, Version 2.0 (the "License");

【朝花夕拾】Android自定義View篇之（七）Android事件分發機制（下）解決滑動衝突

前言        前面兩篇文章，花了很大篇幅講解了Android的事件分發機制的原理性知識。然而，“紙上得來終覺淺，絕知此事要躬行”，前面講的那些原理，也都是為解決實際問題而服務的。本文將結合實際工作中經常遇到的滑動衝突案例，總結滑動衝突的場

NestedScrollView+RecyclerView優雅的解決滑動衝突問題

在此之前，經歷過ScrollView巢狀ScrollView滑動衝突，ScrollView與ListView巢狀滑動衝突等等，網上解決方法比較多暫不贅述了，RecyclerView出來已經差不多2年了，ListView可以說已經成為了過去式了，現在開發完全使用RecyclerView就行了。 我親自

豎直滑動的RecyclerView巢狀豎直滑動的RecyclerView並解決滑動衝突

入職國美三個月了，進入大公司最大的感觸就是人遠比你自己想象的要強大！這一路走來實屬不易，但給我帶來的更多是成長。這裡是人生的起點，也可以說是夢開始的地方，加油吧！ 專案中要求兩個紅框區域列表滑動時吸頂，頭像部分超過四行可上下滑動。 問題①兩個區域吸頂實現：這個比較好實

Android Studio解決依賴衝突

編譯的時候報這個： 所以人家都告訴你了，就是有多個庫同時又引用了rxjava這個庫，然後就不知道用拿個版本了。。。 原因就是我的專案中bmob和rxvolley都用到了rxjava，只要在module的build.gradle下稍微更改下新增依賴的語句就可以了

Recyclerview列表，item巢狀橫向Gridview 解決滑動衝突，資料載入問題

recyclerview列表資料，每個item 巢狀橫向滑動GridView的問題， 這幾天新需求，列表載入使用者關注的人物，一頁15條資料，，，，，，。然後每個人物 都有自己的一系列作品，要在人物頭像之後 ，放一個可以橫著滑動，又支援分頁載入的橫向列表。 剛開始覺得挺容

Android：當滑動衝突遇上RecyclerView

滑動衝突分析很簡單，兩種方法，外部攔截法，內部攔截法。 但是碰上RecyclerView後，我有點懵了。 主要是邏輯的問題，而不是什麼攔截法的問題，當理順了邏輯後，這才感到大徹大悟。 一開始是實現RecyclerView的item的水平監聽。 這還不簡單，可是做著做著，

自定義View解決滑動衝突

最近在讀Android開發藝術探索,本文作為自己對view的滑動衝突的理解和實踐記錄 而滑動衝突,需要了解Android的事件分發機制,如果這個還有些疑惑的地方,請參考這篇文章,以及其中的參考文章 還需要View的Measure和Layout的相關知識Vie

Android PtrFrameLayout 與RecyclerView滑動衝突解決方法

原文地址：https://blog.csdn.net/Simon_Crystin/article/details/80926795   1.背景 2.主要程式碼邏輯 2.1 父View程式碼（PtrFrameLayout） 2.2 子View關鍵程式碼（RecyclerView）

Android：禁止viewpager左右滑動，去除viewpager切換時動畫，解決viewpager與百度地圖滑動衝突

Android自定義viewpager，禁止viewpager左右滑動，去除viewpager切換時動畫，解決viewpager與百度地圖滑動衝突 public class CustomViewPager extends ViewPager { private boolean e

Android ScrollView巢狀Banner於RecyclerView滑動衝突解決

首先是佈局 <?xml version="1.0" encoding="utf-8"?> <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" xmlns:app="http:/

Android 滑動衝突的解決方法

一、常見的滑動衝突場景 場景1——外部滑動方向和內部滑動方向不一致，如：ViewPager中有多個fragment，而fragment中有ListView，這時ViewPager可以左右滑動，而ListView可以上下滑動，這就造成了滑動衝突。注意：這只是舉個例子說明一下場

Android滑動衝突解決方法

敘述 滑動衝突可以說是日常開發中比較常見的一類問題，也是比較讓人頭疼的一類問題，尤其是在使用第三方框架的時候，兩個原本完美的控制元件，組合在一起之後，忽然發現整個世界都不好了。 關於滑動衝突 滑動衝突分類### 滑動衝突，總的來說就是兩類。 同方向滑動衝突 比

Android關於CoordinatorLayout和ListView滑動衝突的解決(上滑ToolBar隱藏，下滑出現)

最近專案中使用到了CoordinatorLayout這種佈局方式,搭配RecycleView,實現起來比較簡單,而且不用自己處理滑動事件,但是改為了ListView後發生了滑動衝突. 所以想到了以下解決方案: 1.使用事件分發,當ListView在Y軸滑動時,將事件交給C

webview輪播圖與Android滑動衝突的解決辦法

在Android中我們經常需要左右滑動，其中內嵌的web頁面也有滑動動作。輪播圖舉例：需要左右翻頁時，會觸發Android中的ViewPager導致翻頁到另一個頁面輪播圖翻頁翻不動，或失效。但是由於安卓是父，而Web是子。在Web中不論你做什麼處理，都管不了父視窗的事情，所以

Android控制元件-ScrollView 和WebView之見滑動衝突解決

   需求：               最近在做一個webView載入網頁的頁面，最外層是一個scrollView，因為還有標題等其他資料是需要單獨獲取載入，所以scrollview中是包含一個其他資訊的頭部佈局和一個載入網頁資訊的WebView，當滑動的時候，頭部和We

android-----滑動衝突解決案例

        之前的幾篇部落格，我測試了View事件分發機制中的一些知識點，我們理解事件分發機制的目的就是為了能夠更好了知道View中事件的傳遞過程進而能夠對於滑動衝突有針對性的解決措施，今天我們通過一個翻頁例項來學習下滑動處理的方式之一-----外部攔截法；      

Android滑動衝突解決方式(下拉重新整理上拉載入更多,適配RecyclerView/ListView/ScrollView)

@Override public boolean judgeIntercept(float curInterceptY, float lastInterceptY, boolean isHeaderShow, boolean isFooterShow, boolean allowLoadM