Android--CoordinatorLayout源码分析及NestedScrolling机制

之前介绍了CoordinatorLayout的基本使用,我们需要一个滚动控件,另外需要给观察者一个Behavior来监听滚动控件的滚动,今天来分析下CoordinatorLayout具体是怎么实现的,怎么把事件分发给我们的Behavior的
首先猜想一下:CoordinatorLayout是一个组件,而我们的Behavior是设置在它的子view的,那么Behavior必然是CoordinatorLayout的一个自定义属性,而我们又知道子view的LayoutParams是由父布局的generateLayoutParams方法生成的,所以我们先来到CoordinatorLayout的generateLayoutParams方法
    @Override
    public LayoutParams generateLayoutParams(AttributeSet attrs) {
        return new LayoutParams(getContext(), attrs);
    }
这边的LayoutParams是CoordinatorLayout的一个内部类
        LayoutParams(Context context, AttributeSet attrs) {
            super(context, attrs);

            final TypedArray a = context.obtainStyledAttributes(attrs,
                    R.styleable.CoordinatorLayout_Layout);

            this.gravity = a.getInteger(
                    R.styleable.CoordinatorLayout_Layout_android_layout_gravity,
                    Gravity.NO_GRAVITY);
            mAnchorId = a.getResourceId(R.styleable.CoordinatorLayout_Layout_layout_anchor,
                    View.NO_ID);
            this.anchorGravity = a.getInteger(
                    R.styleable.CoordinatorLayout_Layout_layout_anchorGravity,
                    Gravity.NO_GRAVITY);

            this.keyline = a.getInteger(R.styleable.CoordinatorLayout_Layout_layout_keyline,
                    -1);

            insetEdge = a.getInt(R.styleable.CoordinatorLayout_Layout_layout_insetEdge, 0);
            dodgeInsetEdges = a.getInt(
                    R.styleable.CoordinatorLayout_Layout_layout_dodgeInsetEdges, 0);
            mBehaviorResolved = a.hasValue(
                    R.styleable.CoordinatorLayout_Layout_layout_behavior);
            //获取自定义属性
            if (mBehaviorResolved) {
                mBehavior = parseBehavior(context, attrs, a.getString(
                        R.styleable.CoordinatorLayout_Layout_layout_behavior));
            }
            a.recycle();

            if (mBehavior != null) {
                // If we have a Behavior, dispatch that it has been attached
                mBehavior.onAttachedToLayoutParams(this);
            }
        }
LayoutParams构造方法中,调用了parseBehavior(context, attrs, a.getString(R.styleable.CoordinatorLayout_Layout_layout_behavior)),将我们自定义的layout_behavior的值传入
    static final Class[] CONSTRUCTOR_PARAMS = new Class[] {
            Context.class,
            AttributeSet.class
    };

    static Behavior parseBehavior(Context context, AttributeSet attrs, String name) {
        if (TextUtils.isEmpty(name)) {
            return null;
        }

        final String fullName;
        if (name.startsWith(".")) {
            // Relative to the app package. Prepend the app package name.
            fullName = context.getPackageName() + name;
        } else if (name.indexOf('.') >= 0) {
            // Fully qualified package name.
            fullName = name;
        } else {
            // Assume stock behavior in this package (if we have one)
            fullName = !TextUtils.isEmpty(WIDGET_PACKAGE_NAME)
                    ? (WIDGET_PACKAGE_NAME + '.' + name)
                    : name;
        }

        try {
            Map> constructors = sConstructors.get();
            if (constructors == null) {
                constructors = new HashMap<>();
                sConstructors.set(constructors);
            }
            Constructor c = constructors.get(fullName);
            if (c == null) {
                final Class clazz = (Class) Class.forName(fullName, true,
                        context.getClassLoader());
                //带参数的构造方法
                c = clazz.getConstructor(CONSTRUCTOR_PARAMS);
                c.setAccessible(true);
                constructors.put(fullName, c);
            }
            return c.newInstance(context, attrs);
        } catch (Exception e) {
            throw new RuntimeException("Could not inflate Behavior subclass " + fullName, e);
        }
    }
parseBehavior方法最终通过反射实例化了我们自定义的Behavior,注意它这边反射的是带有参数的构造方法(Context,AttributeSet),所以我们自定义Behavior时必须要重写带有(Context,AttributeSet)的构造方法。
这个时候我们的Behavior就保存在子View的LayoutParams中,Behavior有了,还差一个滚动控件,但是滚动控件是怎么把它的滚动事件传给CoordinatorLayout的呢?
我们反过来从Behavior的onStartNestedScroll方法进行分析,我们自定义Behavior时,可以通过onStartNestedScroll方法来控制我们需要监听横向的滑动还是竖向的滑动,在CoordinatorLayout中搜索onStartNestedScroll方法
    @Override
    public boolean onStartNestedScroll(View child, View target, int nestedScrollAxes) {
        boolean handled = false;

        final int childCount = getChildCount();
        for (int i = 0; i < childCount; i++) {
            final View view = getChildAt(i);
            final LayoutParams lp = (LayoutParams) view.getLayoutParams();
            //获取每个子View的Behavior
            final Behavior viewBehavior = lp.getBehavior();
            if (viewBehavior != null) {
                //回调Behavior的onStartNestedScroll方法
                final boolean accepted = viewBehavior.onStartNestedScroll(this, view, child, target,
                        nestedScrollAxes);
                handled |= accepted;

                lp.acceptNestedScroll(accepted);
            } else {
                lp.acceptNestedScroll(false);
            }
        }
        return handled;
    }
这边遍历子view并回调Behavior的onStartNestedScroll方法,然而这个方法是Override的,这就说明这原本是父类的方法,或者实现了某个接口
public class CoordinatorLayout extends ViewGroup implements NestedScrollingParent 

public interface NestedScrollingParent {
    /**
     * React to a descendant view initiating a nestable scroll operation, claiming the
     * nested scroll operation if appropriate.
     *
     * 

This method will be called in response to a descendant view invoking * {@link ViewCompat#startNestedScroll(View, int)}. Each parent up the view hierarchy will be * given an opportunity to respond and claim the nested scrolling operation by returning * true.

* *

This method may be overridden by ViewParent implementations to indicate when the view * is willing to support a nested scrolling operation that is about to begin. If it returns * true, this ViewParent will become the target view's nested scrolling parent for the duration * of the scroll operation in progress. When the nested scroll is finished this ViewParent * will receive a call to {@link #onStopNestedScroll(View)}. *

* * @param child Direct child of this ViewParent containing target * @param target View that initiated the nested scroll * @param nestedScrollAxes Flags consisting of {@link ViewCompat#SCROLL_AXIS_HORIZONTAL}, * {@link ViewCompat#SCROLL_AXIS_VERTICAL} or both * @return true if this ViewParent accepts the nested scroll operation */ public boolean onStartNestedScroll(View child, View target, int nestedScrollAxes); /** * React to the successful claiming of a nested scroll operation. * *

This method will be called after * {@link #onStartNestedScroll(View, View, int) onStartNestedScroll} returns true. It offers * an opportunity for the view and its superclasses to perform initial configuration * for the nested scroll. Implementations of this method should always call their superclass's * implementation of this method if one is present.

* * @param child Direct child of this ViewParent containing target * @param target View that initiated the nested scroll * @param nestedScrollAxes Flags consisting of {@link ViewCompat#SCROLL_AXIS_HORIZONTAL}, * {@link ViewCompat#SCROLL_AXIS_VERTICAL} or both * @see #onStartNestedScroll(View, View, int) * @see #onStopNestedScroll(View) */ public void onNestedScrollAccepted(View child, View target, int nestedScrollAxes); /** * React to a nested scroll operation ending. * *

Perform cleanup after a nested scrolling operation. * This method will be called when a nested scroll stops, for example when a nested touch * scroll ends with a {@link MotionEvent#ACTION_UP} or {@link MotionEvent#ACTION_CANCEL} event. * Implementations of this method should always call their superclass's implementation of this * method if one is present.

* * @param target View that initiated the nested scroll */ public void onStopNestedScroll(View target); /** * React to a nested scroll in progress. * *

This method will be called when the ViewParent's current nested scrolling child view * dispatches a nested scroll event. To receive calls to this method the ViewParent must have * previously returned true for a call to * {@link #onStartNestedScroll(View, View, int)}.

* *

Both the consumed and unconsumed portions of the scroll distance are reported to the * ViewParent. An implementation may choose to use the consumed portion to match or chase scroll * position of multiple child elements, for example. The unconsumed portion may be used to * allow continuous dragging of multiple scrolling or draggable elements, such as scrolling * a list within a vertical drawer where the drawer begins dragging once the edge of inner * scrolling content is reached.

* * @param target The descendent view controlling the nested scroll * @param dxConsumed Horizontal scroll distance in pixels already consumed by target * @param dyConsumed Vertical scroll distance in pixels already consumed by target * @param dxUnconsumed Horizontal scroll distance in pixels not consumed by target * @param dyUnconsumed Vertical scroll distance in pixels not consumed by target */ public void onNestedScroll(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. * *

When working with nested scrolling often the parent view may want an opportunity * to consume the scroll before the nested scrolling child does. An example of this is a * drawer that contains a scrollable list. The user will want to be able to scroll the list * fully into view before the list itself begins scrolling.

* *

onNestedPreScroll is called when a nested scrolling child invokes * {@link View#dispatchNestedPreScroll(int, int, int[], int[])}. The implementation should * report how any pixels of the scroll reported by dx, dy were consumed in the * consumed array. Index 0 corresponds to dx and index 1 corresponds to dy. * This parameter will never be null. Initial values for consumed[0] and consumed[1] * will always be 0.

* * @param target View that initiated the nested scroll * @param dx Horizontal scroll distance in pixels * @param dy Vertical scroll distance in pixels * @param consumed Output. The horizontal and vertical scroll distance consumed by this parent */ public void onNestedPreScroll(View target, int dx, int dy, int[] consumed); /** * Request a fling from a nested scroll. * *

This method signifies that a nested scrolling child has detected suitable conditions * for a fling. Generally this means that a touch scroll has ended with a * {@link VelocityTracker velocity} in the direction of scrolling that meets or exceeds * the {@link ViewConfiguration#getScaledMinimumFlingVelocity() minimum fling velocity} * along a scrollable axis.

* *

If a nested scrolling child view would normally fling but it is at the edge of * its own content, it can use this method to delegate the fling to its nested scrolling * parent instead. The parent may optionally consume the fling or observe a child fling.

* * @param target View that initiated the nested scroll * @param velocityX Horizontal velocity in pixels per second * @param velocityY Vertical velocity in pixels per second * @param consumed true if the child consumed the fling, false otherwise * @return true if this parent consumed or otherwise reacted to the fling */ public boolean onNestedFling(View target, float velocityX, float velocityY, boolean consumed); /** * React to a nested fling before the target view consumes it. * *

This method siginfies that a nested scrolling child has detected a fling with the given * velocity along each axis. Generally this means that a touch scroll has ended with a * {@link VelocityTracker velocity} in the direction of scrolling that meets or exceeds * the {@link ViewConfiguration#getScaledMinimumFlingVelocity() minimum fling velocity} * along a scrollable axis.

* *

If a nested scrolling parent is consuming motion as part of a * {@link #onNestedPreScroll(View, int, int, int[]) pre-scroll}, it may be appropriate for * it to also consume the pre-fling to complete that same motion. By returning * true from this method, the parent indicates that the child should not * fling its own internal content as well.

* * @param target View that initiated the nested scroll * @param velocityX Horizontal velocity in pixels per second * @param velocityY Vertical velocity in pixels per second * @return true if this parent consumed the fling ahead of the target view */ public boolean onNestedPreFling(View target, float velocityX, float velocityY); /** * Return the current axes of nested scrolling for this NestedScrollingParent. * *

A NestedScrollingParent returning something other than {@link ViewCompat#SCROLL_AXIS_NONE} * is currently acting as a nested scrolling parent for one or more descendant views in * the hierarchy.

* * @return Flags indicating the current axes of nested scrolling * @see ViewCompat#SCROLL_AXIS_HORIZONTAL * @see ViewCompat#SCROLL_AXIS_VERTICAL * @see ViewCompat#SCROLL_AXIS_NONE */ public int getNestedScrollAxes(); }
果然,我们发现CoordinatorLayout实现了NestedScrollingParent 接口,而NestedScrollingParent 接口中存在onStartNestedScroll方法
到目前为止,CoordinatorLayout把滚动事件传给Behavior的方法我们已经清楚了,现在我们需要找到滚动控件把滚动事件传给CoordinatorLayout的方法,我们来到RecyclerView
public class RecyclerView extends ViewGroup implements ScrollingView, NestedScrollingChild 
CoordinatorLayout实现了NestedScrollingParent ,而RecyclerView 实现了NestedScrollingChild
/**
 * This interface should be implemented by {@link android.view.View View} subclasses that wish
 * to support dispatching nested scrolling operations to a cooperating parent
 * {@link android.view.ViewGroup ViewGroup}.
 *
 * 

Classes implementing this interface should create a final instance of a * {@link NestedScrollingChildHelper} as a field and delegate any View methods to the * NestedScrollingChildHelper methods of the same signature.

* *

Views invoking nested scrolling functionality should always do so from the relevant * {@link ViewCompat}, {@link ViewGroupCompat} or {@link ViewParentCompat} compatibility * shim static methods. This ensures interoperability with nested scrolling views on Android * 5.0 Lollipop and newer.

*/ public interface NestedScrollingChild { /** * Enable or disable nested scrolling for this view. * *

If this property is set to true the view will be permitted to initiate nested * scrolling operations with a compatible parent view in the current hierarchy. If this * view does not implement nested scrolling this will have no effect. Disabling nested scrolling * while a nested scroll is in progress has the effect of {@link #stopNestedScroll() stopping} * the nested scroll.

* * @param enabled true to enable nested scrolling, false to disable * * @see #isNestedScrollingEnabled() */ public void setNestedScrollingEnabled(boolean enabled); /** * Returns true if nested scrolling is enabled for this view. * *

If nested scrolling is enabled and this View class implementation supports it, * this view will act as a nested scrolling child view when applicable, forwarding data * about the scroll operation in progress to a compatible and cooperating nested scrolling * parent.

* * @return true if nested scrolling is enabled * * @see #setNestedScrollingEnabled(boolean) */ public boolean isNestedScrollingEnabled(); /** * Begin a nestable scroll operation along the given axes. * *

A view starting a nested scroll promises to abide by the following contract:

* *

The view will call startNestedScroll upon initiating a scroll operation. In the case * of a touch scroll this corresponds to the initial {@link MotionEvent#ACTION_DOWN}. * In the case of touch scrolling the nested scroll will be terminated automatically in * the same manner as {@link ViewParent#requestDisallowInterceptTouchEvent(boolean)}. * In the event of programmatic scrolling the caller must explicitly call * {@link #stopNestedScroll()} to indicate the end of the nested scroll.

* *

If startNestedScroll returns true, a cooperative parent was found. * If it returns false the caller may ignore the rest of this contract until the next scroll. * Calling startNestedScroll while a nested scroll is already in progress will return true.

* *

At each incremental step of the scroll the caller should invoke * {@link #dispatchNestedPreScroll(int, int, int[], int[]) dispatchNestedPreScroll} * once it has calculated the requested scrolling delta. If it returns true the nested scrolling * parent at least partially consumed the scroll and the caller should adjust the amount it * scrolls by.

* *

After applying the remainder of the scroll delta the caller should invoke * {@link #dispatchNestedScroll(int, int, int, int, int[]) dispatchNestedScroll}, passing * both the delta consumed and the delta unconsumed. A nested scrolling parent may treat * these values differently. See * {@link NestedScrollingParent#onNestedScroll(View, int, int, int, int)}. *

* * @param axes Flags consisting of a combination of {@link ViewCompat#SCROLL_AXIS_HORIZONTAL} * and/or {@link ViewCompat#SCROLL_AXIS_VERTICAL}. * @return true if a cooperative parent was found and nested scrolling has been enabled for * the current gesture. * * @see #stopNestedScroll() * @see #dispatchNestedPreScroll(int, int, int[], int[]) * @see #dispatchNestedScroll(int, int, int, int, int[]) */ public boolean startNestedScroll(int axes); /** * Stop a nested scroll in progress. * *

Calling this method when a nested scroll is not currently in progress is harmless.

* * @see #startNestedScroll(int) */ public void stopNestedScroll(); /** * Returns true if this view has a nested scrolling parent. * *

The presence of a nested scrolling parent indicates that this view has initiated * a nested scroll and it was accepted by an ancestor view further up the view hierarchy.

* * @return whether this view has a nested scrolling parent */ public boolean hasNestedScrollingParent(); /** * Dispatch one step of a nested scroll in progress. * *

Implementations of views that support nested scrolling should call this to report * info about a scroll in progress to the current nested scrolling parent. If a nested scroll * is not currently in progress or nested scrolling is not * {@link #isNestedScrollingEnabled() enabled} for this view this method does nothing.

* *

Compatible View implementations should also call * {@link #dispatchNestedPreScroll(int, int, int[], int[]) dispatchNestedPreScroll} before * consuming a component of the scroll event themselves.

* * @param dxConsumed Horizontal distance in pixels consumed by this view during this scroll step * @param dyConsumed Vertical distance in pixels consumed by this view during this scroll step * @param dxUnconsumed Horizontal scroll distance in pixels not consumed by this view * @param dyUnconsumed Horizontal scroll distance in pixels not consumed by this view * @param offsetInWindow Optional. If not null, on return this will contain the offset * in local view coordinates of this view from before this operation * to after it completes. View implementations may use this to adjust * expected input coordinate tracking. * @return true if the event was dispatched, false if it could not be dispatched. * @see #dispatchNestedPreScroll(int, int, int[], int[]) */ public boolean dispatchNestedScroll(int dxConsumed, int dyConsumed, int dxUnconsumed, int dyUnconsumed, int[] offsetInWindow); /** * Dispatch one step of a nested scroll in progress before this view consumes any portion of it. * *

Nested pre-scroll events are to nested scroll events what touch intercept is to touch. * dispatchNestedPreScroll offers an opportunity for the parent view in a nested * scrolling operation to consume some or all of the scroll operation before the child view * consumes it.

* * @param dx Horizontal scroll distance in pixels * @param dy Vertical scroll distance in pixels * @param consumed Output. If not null, consumed[0] will contain the consumed component of dx * and consumed[1] the consumed dy. * @param offsetInWindow Optional. If not null, on return this will contain the offset * in local view coordinates of this view from before this operation * to after it completes. View implementations may use this to adjust * expected input coordinate tracking. * @return true if the parent consumed some or all of the scroll delta * @see #dispatchNestedScroll(int, int, int, int, int[]) */ public boolean dispatchNestedPreScroll(int dx, int dy, int[] consumed, int[] offsetInWindow); /** * Dispatch a fling to a nested scrolling parent. * *

This method should be used to indicate that a nested scrolling child has detected * suitable conditions for a fling. Generally this means that a touch scroll has ended with a * {@link VelocityTracker velocity} in the direction of scrolling that meets or exceeds * the {@link ViewConfiguration#getScaledMinimumFlingVelocity() minimum fling velocity} * along a scrollable axis.

* *

If a nested scrolling child view would normally fling but it is at the edge of * its own content, it can use this method to delegate the fling to its nested scrolling * parent instead. The parent may optionally consume the fling or observe a child fling.

* * @param velocityX Horizontal fling velocity in pixels per second * @param velocityY Vertical fling velocity in pixels per second * @param consumed true if the child consumed the fling, false otherwise * @return true if the nested scrolling parent consumed or otherwise reacted to the fling */ public boolean dispatchNestedFling(float velocityX, float velocityY, boolean consumed); /** * Dispatch a fling to a nested scrolling parent before it is processed by this view. * *

Nested pre-fling events are to nested fling events what touch intercept is to touch * and what nested pre-scroll is to nested scroll. dispatchNestedPreFling * offsets an opportunity for the parent view in a nested fling to fully consume the fling * before the child view consumes it. If this method returns true, a nested * parent view consumed the fling and this view should not scroll as a result.

* *

For a better user experience, only one view in a nested scrolling chain should consume * the fling at a time. If a parent view consumed the fling this method will return false. * Custom view implementations should account for this in two ways:

* *
    *
  • If a custom view is paged and needs to settle to a fixed page-point, do not * call dispatchNestedPreFling; consume the fling and settle to a valid * position regardless.
  • *
  • If a nested parent does consume the fling, this view should not scroll at all, * even to settle back to a valid idle position.
  • *
* *

Views should also not offer fling velocities to nested parent views along an axis * where scrolling is not currently supported; a {@link android.widget.ScrollView ScrollView} * should not offer a horizontal fling velocity to its parents since scrolling along that * axis is not permitted and carrying velocity along that motion does not make sense.

* * @param velocityX Horizontal fling velocity in pixels per second * @param velocityY Vertical fling velocity in pixels per second * @return true if a nested scrolling parent consumed the fling */ public boolean dispatchNestedPreFling(float velocityX, float velocityY); }
NestedScrollingChild 接口中含有startNestedScroll方法,我们在RecycleView搜索该方法
    @Override
    public boolean startNestedScroll(int axes) {
        return getScrollingChildHelper().startNestedScroll(axes);
    }

    private NestedScrollingChildHelper getScrollingChildHelper() {
        if (mScrollingChildHelper == null) {
            mScrollingChildHelper = new NestedScrollingChildHelper(this);
        }
        return mScrollingChildHelper;
    }
再来到NestedScrollingChildHelper这个类中
/**
 * Helper class for implementing nested scrolling child views compatible with Android platform
 * versions earlier than Android 5.0 Lollipop (API 21).
 *
 * 

{@link android.view.View View} subclasses should instantiate a final instance of this * class as a field at construction. For each View method that has a matching * method signature in this class, delegate the operation to the helper instance in an overridden * method implementation. This implements the standard framework policy for nested scrolling.

* *

Views invoking nested scrolling functionality should always do so from the relevant * {@link android.support.v4.view.ViewCompat}, {@link android.support.v4.view.ViewGroupCompat} or * {@link android.support.v4.view.ViewParentCompat} compatibility * shim static methods. This ensures interoperability with nested scrolling views on Android * 5.0 Lollipop and newer.

*/ public class NestedScrollingChildHelper { private final View mView; private ViewParent mNestedScrollingParent; private boolean mIsNestedScrollingEnabled; private int[] mTempNestedScrollConsumed; /** * Construct a new helper for a given view. */ public NestedScrollingChildHelper(View view) { mView = view; } /** * Enable nested scrolling. * *

This is a delegate method. Call it from your {@link android.view.View View} subclass * method/{@link android.support.v4.view.NestedScrollingChild} interface method with the same * signature to implement the standard policy.

* * @param enabled true to enable nested scrolling dispatch from this view, false otherwise */ public void setNestedScrollingEnabled(boolean enabled) { if (mIsNestedScrollingEnabled) { ViewCompat.stopNestedScroll(mView); } mIsNestedScrollingEnabled = enabled; } /** * Check if nested scrolling is enabled for this view. * *

This is a delegate method. Call it from your {@link android.view.View View} subclass * method/{@link android.support.v4.view.NestedScrollingChild} interface method with the same * signature to implement the standard policy.

* * @return true if nested scrolling is enabled for this view */ public boolean isNestedScrollingEnabled() { return mIsNestedScrollingEnabled; } /** * Check if this view has a nested scrolling parent view currently receiving events for * a nested scroll in progress. * *

This is a delegate method. Call it from your {@link android.view.View View} subclass * method/{@link android.support.v4.view.NestedScrollingChild} interface method with the same * signature to implement the standard policy.

* * @return true if this view has a nested scrolling parent, false otherwise */ public boolean hasNestedScrollingParent() { return mNestedScrollingParent != null; } /** * Start a new nested scroll for this view. * *

This is a delegate method. Call it from your {@link android.view.View View} subclass * method/{@link android.support.v4.view.NestedScrollingChild} interface method with the same * signature to implement the standard policy.

* * @param axes Supported nested scroll axes. * See {@link android.support.v4.view.NestedScrollingChild#startNestedScroll(int)}. * @return true if a cooperating parent view was found and nested scrolling started successfully */ public boolean startNestedScroll(int axes) { if (hasNestedScrollingParent()) { // Already in progress return true; } if (isNestedScrollingEnabled()) { ViewParent p = mView.getParent(); View child = mView; 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; } /** * Stop a nested scroll in progress. * *

This is a delegate method. Call it from your {@link android.view.View View} subclass * method/{@link android.support.v4.view.NestedScrollingChild} interface method with the same * signature to implement the standard policy.

*/ public void stopNestedScroll() { if (mNestedScrollingParent != null) { ViewParentCompat.onStopNestedScroll(mNestedScrollingParent, mView); mNestedScrollingParent = null; } } /** * Dispatch one step of a nested scrolling operation to the current nested scrolling parent. * *

This is a delegate method. Call it from your {@link android.view.View View} subclass * method/{@link android.support.v4.view.NestedScrollingChild} interface method with the same * signature to implement the standard policy.

* * @return true if the parent consumed any of the nested scroll */ public boolean dispatchNestedScroll(int dxConsumed, int dyConsumed, int dxUnconsumed, int dyUnconsumed, int[] offsetInWindow) { if (isNestedScrollingEnabled() && mNestedScrollingParent != null) { 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]; } ViewParentCompat.onNestedScroll(mNestedScrollingParent, mView, dxConsumed, dyConsumed, dxUnconsumed, dyUnconsumed); 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; } /** * Dispatch one step of a nested pre-scrolling operation to the current nested scrolling parent. * *

This is a delegate method. Call it from your {@link android.view.View View} subclass * method/{@link android.support.v4.view.NestedScrollingChild} interface method with the same * signature to implement the standard policy.

* * @return true if the parent consumed any of the nested scroll */ public boolean dispatchNestedPreScroll(int dx, int dy, int[] consumed, int[] offsetInWindow) { if (isNestedScrollingEnabled() && mNestedScrollingParent != null) { 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; ViewParentCompat.onNestedPreScroll(mNestedScrollingParent, mView, dx, dy, consumed); 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; } /** * Dispatch a nested fling operation to the current nested scrolling parent. * *

This is a delegate method. Call it from your {@link android.view.View View} subclass * method/{@link android.support.v4.view.NestedScrollingChild} interface method with the same * signature to implement the standard policy.

* * @return true if the parent consumed the nested fling */ public boolean dispatchNestedFling(float velocityX, float velocityY, boolean consumed) { if (isNestedScrollingEnabled() && mNestedScrollingParent != null) { return ViewParentCompat.onNestedFling(mNestedScrollingParent, mView, velocityX, velocityY, consumed); } return false; } /** * Dispatch a nested pre-fling operation to the current nested scrolling parent. * *

This is a delegate method. Call it from your {@link android.view.View View} subclass * method/{@link android.support.v4.view.NestedScrollingChild} interface method with the same * signature to implement the standard policy.

* * @return true if the parent consumed the nested fling */ public boolean dispatchNestedPreFling(float velocityX, float velocityY) { if (isNestedScrollingEnabled() && mNestedScrollingParent != null) { return ViewParentCompat.onNestedPreFling(mNestedScrollingParent, mView, velocityX, velocityY); } return false; } /** * View subclasses should always call this method on their * NestedScrollingChildHelper when detached from a window. * *

This is a delegate method. Call it from your {@link android.view.View View} subclass * method/{@link android.support.v4.view.NestedScrollingChild} interface method with the same * signature to implement the standard policy.

*/ public void onDetachedFromWindow() { ViewCompat.stopNestedScroll(mView); } /** * Called when a nested scrolling child stops its current nested scroll operation. * *

This is a delegate method. Call it from your {@link android.view.View View} subclass * method/{@link android.support.v4.view.NestedScrollingChild} interface method with the same * signature to implement the standard policy.

* * @param child Child view stopping its nested scroll. This may not be a direct child view. */ public void onStopNestedScroll(View child) { ViewCompat.stopNestedScroll(mView); } }
NestedScrollingChildHelper类含有startNestedScroll方法
    public boolean startNestedScroll(int axes) {
        if (hasNestedScrollingParent()) {
            // Already in progress
            return true;
        }
        if (isNestedScrollingEnabled()) {
            //获取父布局
            ViewParent p = mView.getParent();
            View child = mView;
            while (p != null) {
                //调用ViewParentCompat的onStartNestedScroll方法
                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;
    }
发现它不断的查找父布局,并调用ViewParentCompat的onStartNestedScroll方法,来到ViewParentCompat的onStartNestedScroll方法
    static final ViewParentCompatImpl IMPL;
    static {
        final int version = Build.VERSION.SDK_INT;
        if (version >= 21) {
            IMPL = new ViewParentCompatLollipopImpl();
        } else if (version >= 19) {
            IMPL = new ViewParentCompatKitKatImpl();
        } else if (version >= 14) {
            IMPL = new ViewParentCompatICSImpl();
        } else {
            IMPL = new ViewParentCompatStubImpl();
        }
    }

    public static boolean onStartNestedScroll(ViewParent parent, View child, View target,
            int nestedScrollAxes) {
        return IMPL.onStartNestedScroll(parent, child, target, nestedScrollAxes);
    }
追踪源码发现,最终调用的是ViewParentCompatLollipop 的onStartNestedScroll方法
class ViewParentCompatLollipop {
    private static final String TAG = "ViewParentCompat";

    public static boolean onStartNestedScroll(ViewParent parent, View child, View target,
            int nestedScrollAxes) {
        try {
            return parent.onStartNestedScroll(child, target, nestedScrollAxes);
        } catch (AbstractMethodError e) {
            Log.e(TAG, "ViewParent " + parent + " does not implement interface " +
                    "method onStartNestedScroll", e);
            return false;
        }
    }
.....
}
其实就是调用了父布局的onStartNestedScroll方法,这边找到了滚动控件把滚动事件传递给CoordinatorLayout的源头,并且知道了滚动控件要实现NestedScroll机制的才能传递,像ScrollView就不可以
总结:CoordinatorLayout实现了NestedScrollParent机制,实现NestedScrollChild机制的滚动控件可以将滚动事件传递给实现NestedScrollParent的父布局,所以CoordinatorLayout可以接收到滚动控件的滚动事件,并通过自定义属性Behavior传递给其他的子View,达到协调子控件的作用,CoordinatorLayout就是这么简单

你可能感兴趣的:(Android--CoordinatorLayout源码分析及NestedScrolling机制)