class MyNestScrollView @JvmOverloads constructor(
    val mContext: Context,
    val attributeSet: AttributeSet? = null,
    val flag: Int = 0
) : LinearLayout(mContext, attributeSet, flag) {
    private var mTouchSlop = 0
    private var startY = 0f
    init {
        mTouchSlop = ViewConfiguration.get(context).scaledPagingTouchSlop
    }
    override fun onInterceptTouchEvent(ev: MotionEvent?): Boolean {
        /**什么時(shí)候攔截事件呢，當(dāng)頭部還沒有消失的時(shí)候*/
        return super.onInterceptTouchEvent(ev)
    }
    override fun onTouchEvent(event: MotionEvent?): Boolean {
        when (event?.action) {
            MotionEvent.ACTION_DOWN -> {
                Log.e("TAG", "MyNestScrollView ACTION_DOWN")
                startY = event.y
            }
            MotionEvent.ACTION_MOVE -> {
                Log.e("TAG", "MyNestScrollView ACTION_MOVE")
                val endY = event.y
                if (abs(endY - startY) > mTouchSlop) {
                    //滑動(dòng)了
                    scrollBy(0, (startY - endY).toInt())
                }
                startY = endY
            }
        }
        return super.onTouchEvent(event)
    }
    override fun scrollTo(x: Int, y: Int) {
        var finalY = 0
        if (y < 0) {
        } else {
            finalY = y
        }
        super.scrollTo(x, finalY)
    }
}

public void scrollBy(int x, int y) {
    scrollTo(mScrollX + x, mScrollY + y);
}

override fun scrollTo(x: Int, y: Int) {
    var finalY = 0
    if (y < 0) {
    } else {
        finalY = y
    }
    if (y > mTopViewHeight) {
        finalY = mTopViewHeight
    }
    super.scrollTo(x, finalY)
}
override fun onSizeChanged(w: Int, h: Int, oldw: Int, oldh: Int) {
    super.onSizeChanged(w, h, oldw, oldh)
    //頂部view是第一個(gè)View
    mTopViewHeight = getChildAt(0).measuredHeight
}

/**
 * 頭部View逐漸消失
 * @param dy 手指滑動(dòng)的相對(duì)距離 dy >0 上滑 dy < 0 下滑
 */
private fun isViewHidden(dy: Int): Boolean {
    return dy > 0 && scrollY < mTopViewHeight
}

private fun isViewShow(dy: Int):Boolean{
    return dy < 0 && scrollY > 0 && !canScrollVertically(-1)
}

override fun onInterceptTouchEvent(ev: MotionEvent?): Boolean {
    var intercepted = false
    /**什么時(shí)候攔截事件呢，當(dāng)頭部還沒有消失的時(shí)候*/
    when (ev?.action) {
        MotionEvent.ACTION_DOWN -> {
            startY = ev.rawY
        }
        MotionEvent.ACTION_MOVE -> {
            val endY = ev.rawY
            if (abs(startY - endY) > mTouchSlop) {
                if (isViewHidden((startY - endY).toInt())
                    || isViewShow((startY - endY).toInt())
                ) {
                    Log.e("TAG","此時(shí)就需要攔截，外部進(jìn)行消費(fèi)事件")
                    //此時(shí)就需要攔截，外部進(jìn)行消費(fèi)事件
                    intercepted = true
                }
            }
            startY = endY
        }
    }
    return intercepted
}

public class NestedScrollView extends FrameLayout implements NestedScrollingParent3,
        NestedScrollingChild3, ScrollingView 

public interface NestedScrollingChild {
    /**
     * Enable or disable nested scrolling for this view.
     *
     * 啟動(dòng)或者禁用嵌套滑動(dòng)，如果返回ture，那么說明當(dāng)前布局存在嵌套滑動(dòng)的場(chǎng)景，反之沒有
     * 使用場(chǎng)景：NestedScrollingParent嵌套NestedScrollingChild
     * 在此接口中的方法，都是交給NestedScrollingChildHelper代理類實(shí)現(xiàn)
     */
    void setNestedScrollingEnabled(boolean enabled);
    /**
     * Returns true if nested scrolling is enabled for this view.
     * 其實(shí)就是返回setNestedScrollingEnabled中設(shè)置的值
     */
    boolean isNestedScrollingEnabled();
    /**
     * Begin a nestable scroll operation along the given axes.
     * 表示view開始滾動(dòng)了,一般是在ACTION_DOWN中調(diào)用，如果返回true則表示父布局支持嵌套滾動(dòng)。
     * 一般也是直接代理給NestedScrollingChildHelper的同名方法即可。這個(gè)時(shí)候正常情況會(huì)觸發(fā)Parent的onStartNestedScroll()方法
     */
    boolean startNestedScroll(@ScrollAxis int axes);
    /**
     * Stop a nested scroll in progress.
     * 停止嵌套滾動(dòng)，一般在UP或者CANCEL事件中執(zhí)行，告訴父容器已經(jīng)停止了嵌套滑動(dòng)
     */
    void stopNestedScroll();
    /**
     * Returns true if this view has a nested scrolling parent.
     * 判斷當(dāng)前View是否存在嵌套滑動(dòng)的Parent
     */
    boolean hasNestedScrollingParent();
    /**
    * 當(dāng)前View消費(fèi)滑動(dòng)事件之后，滾動(dòng)一段距離之后，把剩余的距離回調(diào)給父容器，父容器知道當(dāng)前剩余距離
    * dxConsumed：x軸滾動(dòng)的距離
    * dyConsumed：y軸滾動(dòng)的距離
    * dxUnconsumed：x軸未消費(fèi)的距離
    * dyUnconsumed：y軸未消費(fèi)的距離
    * 這個(gè)方法是嵌套滑動(dòng)的時(shí)候調(diào)用才有用，返回值 true分發(fā)成功；false 分發(fā)失敗
    */
    boolean dispatchNestedScroll(int dxConsumed, int dyConsumed,
            int dxUnconsumed, int dyUnconsumed, @Nullable int[] offsetInWindow);
    /**
     * Dispatch one step of a nested scroll in progress before this view consumes any portion of it.
     * 在子View消費(fèi)滑動(dòng)距離之前，將滑動(dòng)距離傳遞給父容器，相當(dāng)于把消費(fèi)權(quán)交給parent
     * dx：當(dāng)前水平方向滑動(dòng)的距離
     * dy：當(dāng)前垂直方向滑動(dòng)的距離
     * consumed：輸出參數(shù)，會(huì)將Parent消費(fèi)掉的距離封裝進(jìn)該參數(shù)consumed[0]代表水平方向，consumed[1]代表垂直方向
    * @return true：代表Parent消費(fèi)了滾動(dòng)距離
     */
    boolean dispatchNestedPreScroll(int dx, int dy, @Nullable int[] consumed,
            @Nullable int[] offsetInWindow);
    /**
     * Dispatch one step of a nested scroll in progress.
     * 處理慣性事件，與dispatchNestedScroll類似，也是在消費(fèi)事件之后，將消費(fèi)和未消費(fèi)的距離都傳遞給父容器
     */
    boolean dispatchNestedFling(float velocityX, float velocityY, boolean consumed);
    /**
     * Dispatch a fling to a nested scrolling parent before it is processed by this view.
     * 與dispatchNestedPreScroll類似，在消費(fèi)之前首先會(huì)傳遞給父容器，把優(yōu)先處理權(quán)交給父容器
     */
    boolean dispatchNestedPreFling(float velocityX, float velocityY);
}

public interface NestedScrollingParent {
    /**
     * React to a descendant view initiating a nestable scroll operation, claiming the
     * nested scroll operation if appropriate.
     * 當(dāng)子View調(diào)用startNestedScroll方法的時(shí)候，父容器會(huì)在這個(gè)方法中獲取回調(diào)
     */
    boolean onStartNestedScroll(@NonNull View child, @NonNull View target, @ScrollAxis int axes);
    /**
     * React to the successful claiming of a nested scroll operation.
     * 在onStartNestedScroll調(diào)用之后，就緊接著調(diào)用這個(gè)方法
     */
    void onNestedScrollAccepted(@NonNull View child, @NonNull View target, @ScrollAxis int axes);
    /**
     * React to a nested scroll operation ending.
     * 當(dāng)子View調(diào)用 stopNestedScroll方法的時(shí)候回調(diào)
     */
    void onStopNestedScroll(@NonNull View target);
    /**
     * React to a nested scroll in progress.
     * 
     */
    void onNestedScroll(@NonNull View target, int dxConsumed, int dyConsumed,
            int dxUnconsumed, int dyUnconsumed);
    /**
     * React to a nested scroll in progress before the target view consumes a portion of the scroll.
     * 在子View調(diào)用dispatchNestedPreScroll之后，這個(gè)方法拿到了回調(diào)
     * 
     */
    void onNestedPreScroll(@NonNull View target, int dx, int dy, @NonNull int[] consumed);
    /**
     * Request a fling from a nested scroll.
     *
     */
    boolean onNestedFling(@NonNull View target, float velocityX, float velocityY, boolean consumed);
    /**
     * React to a nested fling before the target view consumes it.
     *
     */
    boolean onNestedPreFling(@NonNull View target, float velocityX, float velocityY);
    /**
     * Return the current axes of nested scrolling for this NestedScrollingParent.
     * 返回當(dāng)前滑動(dòng)的方向
     */
    @ScrollAxis
    int getNestedScrollAxes();
}

override fun onTouchEvent(e: MotionEvent?): Boolean {
    when(e?.action){
        MotionEvent.ACTION_DOWN->{
            mStartX = e.y.toInt()
            //子View開始嵌套滑動(dòng)
            var axis = ViewCompat.SCROLL_AXIS_NONE
            axis = axis or ViewCompat.SCROLL_AXIS_VERTICAL
            nestedScrollingChildHelper.startNestedScroll(axis)
        }
        MotionEvent.ACTION_MOVE->{
        }
    }
    return super.onTouchEvent(e)
}

public boolean startNestedScroll(@ScrollAxis int axes, @NestedScrollType int type) {
    if (hasNestedScrollingParent(type)) {
        // Already in progress
        return true;
    }
    if (isNestedScrollingEnabled()) {
        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;
}

public boolean hasNestedScrollingParent(@NestedScrollType int type) {
    return getNestedScrollingParentForType(type) != null;
private ViewParent getNestedScrollingParentForType(@NestedScrollType int type) {
    switch (type) {
        case TYPE_TOUCH:
            return mNestedScrollingParentTouch;
        case TYPE_NON_TOUCH:
            return mNestedScrollingParentNonTouch;
    }
    return null;
}

while (p != null) {
    //---------- 判斷條件1 -------------//
    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();
}

public static boolean onStartNestedScroll(@NonNull ViewParent parent, @NonNull View child,
        @NonNull View target, int nestedScrollAxes, int type) {
    if (parent instanceof NestedScrollingParent2) {
        // First try the NestedScrollingParent2 API
        return ((NestedScrollingParent2) parent).onStartNestedScroll(child, target,
                nestedScrollAxes, type);
    } else if (type == ViewCompat.TYPE_TOUCH) {
        // Else if the type is the default (touch), try the NestedScrollingParent API
        if (Build.VERSION.SDK_INT >= 21) {
            try {
                return Api21Impl.onStartNestedScroll(parent, child, target, nestedScrollAxes);
            } catch (AbstractMethodError e) {
                Log.e(TAG, "ViewParent " + parent + " does not implement interface "
                        + "method onStartNestedScroll", e);
            }
        } else if (parent instanceof NestedScrollingParent) {
            return ((NestedScrollingParent) parent).onStartNestedScroll(child, target,
                    nestedScrollAxes);
        }
    }
    return false;
}

private void setNestedScrollingParentForType(@NestedScrollType int type, ViewParent p) {
    switch (type) {
        case TYPE_TOUCH:
            mNestedScrollingParentTouch = p;
            break;
        case TYPE_NON_TOUCH:
            mNestedScrollingParentNonTouch = p;
            break;
    }
}

override fun onStartNestedScroll(child: View, target: View, axes: Int): Boolean {
    Log.e("TAG","onStartNestedScroll")
    //這里需要return true，否則在子View中分發(fā)事件就不會(huì)成功
    return true
}
override fun onNestedScrollAccepted(child: View, target: View, axes: Int) {
    Log.e("TAG","onNestedScrollAccepted")
}

public boolean dispatchNestedPreScroll(int dx, int dy, @Nullable int[] consumed,
        @Nullable int[] offsetInWindow, @NestedScrollType int type) {
    if (isNestedScrollingEnabled()) {
        //這里不為空了
        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) {
                consumed = getTempNestedScrollConsumed();
            }
            consumed[0] = 0;
            consumed[1] = 0;
            ViewParentCompat.onNestedPreScroll(parent, mView, dx, dy, consumed, type);
            if (offsetInWindow != null) {
                mView.getLocationInWindow(offsetInWindow);
                offsetInWindow[0] -= startX;
                offsetInWindow[1] -= startY;
            }
            //-------- 由父容器是否消費(fèi)決定返回值 -------//
            return consumed[0] != 0 || consumed[1] != 0;
        } else if (offsetInWindow != null) {
            offsetInWindow[0] = 0;
            offsetInWindow[1] = 0;
        }
    }
    return false;
}

override fun onNestedPreScroll(target: View, dx: Int, dy: Int, consumed: IntArray) {
    Log.e("TAG", "onNestedPreScroll")
    //父容器什么時(shí)候 消費(fèi)呢？
    if (isViewShow(dy) || isViewHidden(dy)) {
        //假設(shè)這個(gè)時(shí)候把事件全消費(fèi)了
        consumed[1] = dy
        scrollBy(0, dy)
    }
}

MotionEvent.ACTION_MOVE -> {
    val endY = e.y.toInt()
    val endX = e.x.toInt()
    var dx = mStartX - endX
    var dy = mStartY - endY
    //進(jìn)行事件分發(fā)，優(yōu)先給parent
    if (dispatchNestedPreScroll(dx, dy, cosumed, null)) {
        //如果父容器消費(fèi)過事件，這個(gè)時(shí)候，cosumed有值了，我們只關(guān)心dy
        dy -= cosumed[1]
        if (dy == 0) {
            //代表父容器全給消費(fèi)了
            return true
        }
    } else {
        //如果沒有消費(fèi)事件，那么就子view消費(fèi)吧
        smoothScrollBy(dx, dy)
    }
}

MotionEvent.ACTION_UP->{
    nestedScrollingChildHelper.stopNestedScroll()
}

public void stopNestedScroll(@NestedScrollType int type) {
    ViewParent parent = getNestedScrollingParentForType(type);
    if (parent != null) {
        ViewParentCompat.onStopNestedScroll(parent, mView, type);
        setNestedScrollingParentForType(type, null);
    }
}