android嵌套滚动nestedscrolling

class ChildView implements NestedScrollingChild { 
	
	@Override
	public boolean onTouchEvent(MotionEvent event) { 
	    boolean result = false; 
	
	    MotionEvent trackedEvent = MotionEvent.obtain(event); 
	
	    final int action = MotionEventCompat.getActionMasked(event); 
	
	    if (action == MotionEvent.ACTION_DOWN) { 
	        mNestedYOffset = 0; 
	    } 
	
	    int y = (int) event.getY(); 
	    event.offsetLocation(0, mNestedYOffset); 
	
	    switch (action) { 
	        case MotionEvent.ACTION_DOWN: 
	            mLastMotionY = y; 
	            // 1.开始嵌套滚动，并确定滚动方向
	            startNestedScroll(ViewCompat.SCROLL_AXIS_VERTICAL); 
	            result = super.onTouchEvent(event); 
	            break;
	        
	        case MotionEvent.ACTION_MOVE: 
	            int deltaY = mLastMotionY - y; 
	            
	            // 3.子View计算偏移量传给父View
	            if (dispatchNestedPreScroll(0, deltaY, mScrollConsumed, mScrollOffset)) { 
	                // mScrollConsumed 保存被parent消费的尺寸 
	                deltaY -= mScrollConsumed[1]; 
	                trackedEvent.offsetLocation(0, mScrollOffset[1]); 
	                mNestedYOffset += mScrollOffset[1]; 
	            } 
	
	            mLastMotionY = y - mScrollOffset[1]; 
	
				// 5.根据父View消费后的偏移余量，计算自己还能用多少，还能再剩下多少给父View继续使用
	            int oldY = getScrollY(); 
	            int newScrollY = Math.max(0, oldY + deltaY); 
	            int dyConsumed = newScrollY - oldY;
	            int dyUnconsumed = deltaY - dyConsumed; 
	
	            if (dispatchNestedScroll(0, dyConsumed, 0, dyUnconsumed, mScrollOffset)) { 
	                mLastMotionY -= mScrollOffset[1]; 
	                trackedEvent.offsetLocation(0, mScrollOffset[1]); 
	                mNestedYOffset += mScrollOffset[1]; 
	            } 
	
	            result = super.onTouchEvent(trackedEvent); 
	            trackedEvent.recycle(); 
	            break;
	        case MotionEvent.ACTION_POINTER_DOWN: 
	        case MotionEvent.ACTION_UP: 
	        case MotionEvent.ACTION_CANCEL: 
        		// 7.结束流程
	            stopNestedScroll();
	            result = super.onTouchEvent(event); 
	            break;
	    } 
	    return result; 
	}
}

class ParentView implements NestedScrollParent { 

	// 2.父View根据传来的方向，决定是否联动
	@Override
	public boolean onStartNestedScroll(View child, View target, int nestedScrollAxes) { 
		return (nestedScrollAxes & ViewCompat.SCROLL_AXIS_VERTICAL) != 0;
	}
	
	// 4.计算需要消耗的偏移量，移动子View
	@Override
	public void onNestedPreScroll(View target, int dx, int dy, int[] consumed) { 
	    if (dy > 0) {
		    int dyCanConsumed = mTargetCurOffset - mTargetEndOffset;
		    if (dy >= dyCanConsumed) {
		        consumed[1] = dyCanConsumed;
		        moveTo(mTargetEndOffset);
		    } else {
		        consumed[1] = dy;
		        moveBy(-dy);
		    }
		}
	}

	// 6.父View根据子View的计算结果，做相关处理
	@Override
	public void onNestedScroll(View target, int dxConsumed, int dyConsumed, int dxUnconsumed, int dyUnconsumed) {
	    if (dyUnconsumed < 0) {
	        moveBy(-dyUnconsumed);
	    }
	}
}

public boolean startNestedScroll(int axes) { 
    if (hasNestedScrollingParent()) { 
        // Already in progress 
        return true; 
    } 
    if (isNestedScrollingEnabled()) { 
        ViewParent p = mView.getParent(); 
        View child = mView; 

        // 向上遍历找parent，直到找到实现NestScrollParentHelper.onStartNestScroll()返回true的parent
        // 注意，ViewGroup也实现了NestScrollParentHelper，但是onStartNestScroll()返回false
        while (p != null) { 
            if (ViewParentCompat.onStartNestedScroll(p, child, mView, axes)) { 
                mNestedScrollingParent = p; 
                ViewParentCompat.onNestedScrollAccepted(p, child, mView, axes); 
                return true;
            } 
            if (p instanceof View) { 
                child = (View) p;
            } 
            p = p.getParent();
        } 
    }
    return false; 
}