zoukankan      html  css  js  c++  java
  • 使用Android SwipeRefreshLayout了解Android的嵌套滑动机制

    SwipeRefreshLayout 是Android Support Library, revision 19.1.0加入support v4库中的一个下拉刷新控件,关于android的下拉刷新框架如今有好多,以前用过XListView,如今工作中基本上无需用到下拉刷新的功能。

    废话不多说了。这里来记录一下android自带的刷新控件SwipeRefreshLayout的使用,借此顺便来熟悉一下android 在Lollipop版本号推出的嵌套滑动机制(NestedScrolling)。

    首先来看SwipeRefreshLayout的使用,使用非常easy。看一下布局文件

    <?xml version="1.0" encoding="utf-8"?

    > <android.support.v4.widget.SwipeRefreshLayout xmlns:android="http://schemas.android.com/apk/res/android" xmlns:tools="http://schemas.android.com/tools" android:id="@+id/swiperefresh" android:layout_width="match_parent" android:layout_height="match_parent" tools:context="cj.com.recyclerviewdemo.RecyclerViewActivity"> <android.support.v7.widget.RecyclerView android:id="@+id/my_recycler_view" android:layout_width="match_parent" android:layout_height="wrap_content"/> </android.support.v4.widget.SwipeRefreshLayout>

    注意SwipeRefreshLayout仅仅能有一个直接的子View。这里用了RecyclerView,由于前面刚刚讲过它。其有用啥子View都行。仅仅要你想通过竖直方向的滑动来刷新该View的显示内容。

    关于SwipeRefreshLayout的一些API:

    swipeRefreshLayout = (SwipeRefreshLayout) findViewById(R.id.swiperefresh);
            mRecyclerView = (RecyclerView) findViewById(R.id.my_recycler_view);
            swipeRefreshLayout.setSize(SwipeRefreshLayout.LARGE);
            //swipeRefreshLayout.setSize(SwipeRefreshLayout.DEFAULT);//默认  设置进度圈的大小,仅仅有两个值:DEFAULT、LARGE
            //swipeRefreshLayout.setProgressBackgroundColorSchemeColor(Color.RED);//设置进度圈的背景色。
            //swipeRefreshLayout.setColorSchemeResources(R.color.colorPrimaryDark,R.color.colorPrimary,R.color.cardViewcolor);//设置进度动画的颜色
          .....
            swipeRefreshLayout.setOnRefreshListener(new SwipeRefreshLayout.OnRefreshListener() {
                @Override
                public void onRefresh() {
                    Log.d("test","onRefresh");
                    datas.add(0,new Contact("xiaochen","10086"));
                    handler.postDelayed(new Runnable() {
                        @Override
                        public void run() {
                            mAdapter.notifyDataSetChanged();
    
                            swipeRefreshLayout.setRefreshing(false);//设置刷新状态 false停止刷新
                        }
                    },5000);
                }
            });

    这里还是依据前文的demo来写的,就刷新的时候,在第一个位置加入一条数据,咱看效果:



    SwipeRefreshLayout的使用没啥好讲的。比較简单。

    咱再一张效果图:



    注意上面我就传一个事件流,即一个down事件,N个Move事件,一个up事件,然而我们能够发现Move事件的时候被SwipeRefreshLayout(出现进度圈)和RecyclerView(向上滚动)都处理了,记得前面源代码分析Android触摸事件处理机制一文我们分析过,android默认的触摸事件处理框架一个事件流仅仅能被一个View处理,当然通过一些手段还是能够做到一个事件流同一时候被几个View处理,显然SwipeRefreshLayout和RecyclerView对触摸事件的处理流程做了一定处理。

    所以咱来看看SwipeRefreshLayout和RecyclerView的 源代码,这里就不是去分析它们源代码看它们怎么处理事件。仅仅是引出嵌套滑动的机制:

    public class SwipeRefreshLayout extends ViewGroup implements NestedScrollingParent,
            NestedScrollingChild {


     private final NestedScrollingParentHelper mNestedScrollingParentHelper;
        private final NestedScrollingChildHelper mNestedScrollingChildHelper;
    SwipeRefreshLayout实现了NestedScrollingParent接口,同一时候它也有一个成员变量是NestedScrollingParentHelper类型

    public class RecyclerView extends ViewGroup implements ScrollingView, NestedScrollingChild {

     private NestedScrollingChildHelper mScrollingChildHelper;

    RecyclerView实现了NestedScrollingChild接口,同一时候它也有一个成员变量是NestedScrollingChildHelper类型
    发现了四个新的对象NestedScrollingParent,NestedScrollingChild,NestedScrollingChildHelper,NestedScrollingParentHelper。

    前面说嵌套滑动机制主要由上面四个对象来实现的,SwipeRefreshLayout和RecyclerView之间就是利用嵌套滑动来实现下拉刷新的,大家有兴趣能够阅读源代码去分析。以下讲一下android这个嵌套滑动机制

    Android 在公布 Lollipop版本号之后。为了更好的用户体验,Google为Android的滑动机制提供了NestedScrolling特性

    理解嵌套滑动,须要理解以下几个类(接口):
    NestedScrollingChild
    NestedScrollingParent
    NestedScrollingChildHelper
    NestedScrollingParentHelper
    以上四个类都在support-v4包(Android Support Library, revision 22.1.0加入的)中提供。Lollipop的View默认实现了几种方法。

    先来看  NestedScrollingChild 接口,  顾名思义, 这个是子View 应该实现 的接口:

    /*
     * Copyright (C) 2015 The Android Open Source Project
     *
     * Licensed under the Apache License, Version 2.0 (the "License");
     * you may not use this file except in compliance with the License.
     * You may obtain a copy of the License at
     *
     *      http://www.apache.org/licenses/LICENSE-2.0
     *
     * Unless required by applicable law or agreed to in writing, software
     * distributed under the License is distributed on an "AS IS" BASIS,
     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     * See the License for the specific language governing permissions and
     * limitations under the License.
     */
    
    
    package android.support.v4.view;
    
    import android.view.MotionEvent;
    import android.view.VelocityTracker;
    import android.view.View;
    import android.view.ViewConfiguration;
    import android.view.ViewParent;
    
    /**
     * 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}.
     *
     * <p>Classes implementing this interface should create a final instance of a
     * {@link NestedScrollingChildHelper} as a field and delegate any View methods to the
     * <code>NestedScrollingChildHelper</code> methods of the same signature.</p>
     *
     * <p>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.</p>
     */
    public interface NestedScrollingChild {
        /**
         * Enable or disable nested scrolling for this view.
         *
         * <p>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.</p>
         *
         * @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.
         *
         * <p>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.</p>
         *
         * @return true if nested scrolling is enabled
         *
         * @see #setNestedScrollingEnabled(boolean)
         */
        public boolean isNestedScrollingEnabled();
    
        /**
         * Begin a nestable scroll operation along the given axes.
         *
         * <p>A view starting a nested scroll promises to abide by the following contract:</p>
         *
         * <p>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.</p>
         *
         * <p>If <code>startNestedScroll</code> 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.</p>
         *
         * <p>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.</p>
         *
         * <p>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)}.
         * </p>
         *
         * @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.
         *
         * <p>Calling this method when a nested scroll is not currently in progress is harmless.</p>
         *
         * @see #startNestedScroll(int)
         */
        public void stopNestedScroll();
    
        /**
         * Returns true if this view has a nested scrolling parent.
         *
         * <p>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.</p>
         *
         * @return whether this view has a nested scrolling parent
         */
        public boolean hasNestedScrollingParent();
    
        /**
         * Dispatch one step of a nested scroll in progress.
         *
         * <p>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.</p>
         *
         * <p>Compatible View implementations should also call
         * {@link #dispatchNestedPreScroll(int, int, int[], int[]) dispatchNestedPreScroll} before
         * consuming a component of the scroll event themselves.</p>
         *
         * @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.
         *
         * <p>Nested pre-scroll events are to nested scroll events what touch intercept is to touch.
         * <code>dispatchNestedPreScroll</code> 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.</p>
         *
         * @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.
         *
         * <p>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.</p>
         *
         * <p>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.</p>
         *
         * @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.
         *
         * <p>Nested pre-fling events are to nested fling events what touch intercept is to touch
         * and what nested pre-scroll is to nested scroll. <code>dispatchNestedPreFling</code>
         * 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 <code>true</code>, a nested
         * parent view consumed the fling and this view should not scroll as a result.</p>
         *
         * <p>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:</p>
         *
         * <ul>
         *     <li>If a custom view is paged and needs to settle to a fixed page-point, do not
         *     call <code>dispatchNestedPreFling</code>; consume the fling and settle to a valid
         *     position regardless.</li>
         *     <li>If a nested parent does consume the fling, this view should not scroll at all,
         *     even to settle back to a valid idle position.</li>
         * </ul>
         *
         * <p>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.</p>
         *
         * @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);
    }
    
    有9个函数,简单说明一下:

    1,setNestedScrollingEnabled 实现该接口的View要调用setNestedScrollingEnabled(true)才干够使用嵌套滚动.

    2,isNestedScrollingEnabled推断当前view是否能使用嵌套滚动.

    3,startNestedScroll和stopNestedScroll.是配对使用的.startNestedScroll表示view開始滚动了,通常是在ACTION_DOWN中调用。是来查找是否有嵌套处理的父View.在事件结束比方ACTION_UP或者ACTION_CANCLE中调用stopNestedScroll,告诉父布局滚动结束.

    4dispatchNestedPreScroll,在该view消费滚动距离之前把总得滑动距离传给父布局.

    5,dispatchNestedScroll,在该view消费滚动距离之后,把剩下的滑动距离再次传给父布局.

    6,dispatchNestedFling和dispatchNestedPreFling就是把view传递滑动的信息给父布局的.比方滑动速度

    NestedScrollingChildHelper这个类是一个辅助类就来把View的消息传递嵌套的父View。

    所以上面函数内部实现基本上都是调用NestedScrollingChildHelper这类的函数,咱看一个:

    NestedScrollingChildHelper的startNestedScroll()函数。一般就是在NestedScrollingChild的startNestedScroll()函数里调用。參数表示方向,有两个值ViewCompat.SCROLL_AXIS_HORIZONTAL ,ViewCompat.SCROLL_AXIS_VERTICAL

    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;
        }
    

    上面就是寻找能够响应嵌套滑动的父View,也就是调用父类的onStartNestedScroll(),这个函数是NestedScrollingParent接口的函数。所以嵌套滑动的父View要实现这个接口,接着往下看,最后会有一个demo測试嵌套滑动

    接着来看NestedScrollingParent这个接口:

    /*
     * Copyright (C) 2015 The Android Open Source Project
     *
     * Licensed under the Apache License, Version 2.0 (the "License");
     * you may not use this file except in compliance with the License.
     * You may obtain a copy of the License at
     *
     *      http://www.apache.org/licenses/LICENSE-2.0
     *
     * Unless required by applicable law or agreed to in writing, software
     * distributed under the License is distributed on an "AS IS" BASIS,
     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     * See the License for the specific language governing permissions and
     * limitations under the License.
     */
    
    
    package android.support.v4.view;
    
    import android.view.MotionEvent;
    import android.view.VelocityTracker;
    import android.view.View;
    import android.view.ViewConfiguration;
    
    /**
     * This interface should be implemented by {@link android.view.ViewGroup ViewGroup} subclasses
     * that wish to support scrolling operations delegated by a nested child view.
     *
     * <p>Classes implementing this interface should create a final instance of a
     * {@link NestedScrollingParentHelper} as a field and delegate any View or ViewGroup methods
     * to the <code>NestedScrollingParentHelper</code> methods of the same signature.</p>
     *
     * <p>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.</p>
     */
    public interface NestedScrollingParent {
        /**
         * React to a descendant view initiating a nestable scroll operation, claiming the
         * nested scroll operation if appropriate.
         *
         * <p>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
         * <code>true</code>.</p>
         *
         * <p>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)}.
         * </p>
         *
         * @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.
         *
         * <p>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.</p>
         *
         * @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.
         *
         * <p>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.</p>
         *
         * @param target View that initiated the nested scroll
         */
        public void onStopNestedScroll(View target);
    
        /**
         * React to a nested scroll in progress.
         *
         * <p>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 <code>true</code> for a call to
         * {@link #onStartNestedScroll(View, View, int)}.</p>
         *
         * <p>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.</p>
         *
         * @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.
         *
         * <p>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.</p>
         *
         * <p><code>onNestedPreScroll</code> 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
         * <code>consumed</code> 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.</p>
         *
         * @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.
         *
         * <p>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.</p>
         *
         * <p>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.</p>
         *
         * @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.
         *
         * <p>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.</p>
         *
         * <p>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
         * <code>true</code> from this method, the parent indicates that the child should not
         * fling its own internal content as well.</p>
         *
         * @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.
         *
         * <p>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.</p>
         *
         * @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();
    }
    

    8个函数。简介一下:

    1,onStartNestedScroll.当子view的调用NestedScrollingChild的方法startNestedScroll时,会调用该方法.前面分析到了

    2,onNestedScrollAccepted.假设onStartNestedScroll方法返回的是true的话,那么紧接着就会调用该方法.它是让嵌套滚动在開始滚动之前,让布局容器(viewGroup)或者它的父类运行一些配置的初始化的.

    3,onStopNestedScroll停止滚动了,当子view调用stopNestedScroll时会调用该方法.

    4,onNestedScroll,当子view调用dispatchNestedScroll方法时,会调用该方法.

    5,onNestedPreScroll,当子view调用dispatchNestedPreScroll方法是,会调用该方法.

    6,dispatchNestedFling和dispatchNestedPreFling相应的就是滑动了.

    相同NestedScrollingParent也有一个帮助类NestedScrollingParentHelper来实现嵌套滑动

    由上能够知道这四个类(接口)两两相应,以下一个表格表示相应方法调用顺序,借了一张图过来


    还有另外两个相应函数没贴上。

    以下通过一个demo来測试一下。毕竟讲的再多不如实践一次

    来张效果图:


    demo实现就是滑动子View的时候假设滑动距离小于某个值。就仅仅平移父View(滑动距离所有给父View消耗),当大于这个值时。两者之差的值就让子View平移,这里仅仅是測试函数调用顺序,一些数据处理大家不要在意哈。
    看代码:
    子View:
    package cj.com.nestedscrollingdemo;
    
    import android.content.Context;
    import android.support.v4.view.NestedScrollingChildHelper;
    import android.support.v4.view.ViewCompat;
    import android.util.AttributeSet;
    import android.util.Log;
    import android.view.MotionEvent;
    import android.view.View;
    
    public class NestScrollingView extends View {
        private static final String TAG = "Test";
    
        private NestedScrollingChildHelper mChildHelper;
    
        private int[] mConsumed = new int[2];
    
        private int[] mOffset = new int[2];
        public NestScrollingView(Context context) {
            super(context);
            init();
        }
    
        public NestScrollingView(Context context, AttributeSet attrs) {
            super(context, attrs);
            init();
        }
    
        public NestScrollingView(Context context, AttributeSet attrs, int defStyleAttr) {
            super(context, attrs, defStyleAttr);
            init();
        }
    
        private void init() {
            mChildHelper = new NestedScrollingChildHelper(this);
            setNestedScrollingEnabled(true);
        }
    
        @Override
        public void setNestedScrollingEnabled(boolean enabled) {
            mChildHelper.setNestedScrollingEnabled(enabled);
        }
    
        @Override
        public boolean isNestedScrollingEnabled() {
            return mChildHelper.isNestedScrollingEnabled();
            //return super.isNestedScrollingEnabled();
        }
    
        @Override
        public boolean startNestedScroll(int axes) {//
            Log.d(TAG, "NestScrollingView  startNestedScroll");
            return mChildHelper.startNestedScroll(axes);
            //return super.startNestedScroll(axes);
        }
    
        @Override
        public void stopNestedScroll() {
            Log.d(TAG, "NestScrollingView  stopNestedScroll");
            mChildHelper.stopNestedScroll();
           // super.stopNestedScroll();
        }
    
        @Override
        public boolean hasNestedScrollingParent() {
            Log.d(TAG, "NestScrollingView  hasNestedScrollingParent");
            return mChildHelper.hasNestedScrollingParent();
            //return super.hasNestedScrollingParent();
        }
    
        @Override
        public boolean dispatchNestedScroll(int dxConsumed, int dyConsumed, int dxUnconsumed, int dyUnconsumed, int[] offsetInWindow) {
            Log.d(TAG, "NestScrollingView  dispatchNestedScroll");
            return mChildHelper.dispatchNestedScroll(dxConsumed,dyConsumed,
                    dxUnconsumed,dyUnconsumed,offsetInWindow);
            //return super.dispatchNestedScroll(dxConsumed, dyConsumed, dxUnconsumed, dyUnconsumed, offsetInWindow);
        }
    
        /**
         *
         * @param dx X方向的偏移量 传给父View 先让父View处理
         * @param dy y方向的偏移量
         * @param consumed  一个数组,   表示 x 方向 或 y 方向的偏移量 是否有被父View消费 返回的数据是父View消耗了多少
         * @param offsetInWindow  父View消费滑动事件后 导致该View的偏移量  这个由NestedScrollingChildHelper内部处理
         * @return  父View 是否消耗了传入的偏移
         */
        @Override
        public boolean dispatchNestedPreScroll(int dx, int dy, int[] consumed, int[] offsetInWindow) {
            Log.d(TAG, "NestScrollingView  dispatchNestedPreScroll");
            return mChildHelper.dispatchNestedPreScroll(dx,dy,
                    consumed,offsetInWindow);
           // return super.dispatchNestedPreScroll(dx, dy, consumed, offsetInWindow);
        }
    
        @Override
        public boolean dispatchNestedFling(float velocityX, float velocityY, boolean consumed) {
            Log.d(TAG, "NestScrollingView  dispatchNestedFling");
            return mChildHelper.dispatchNestedFling(velocityX,velocityY,
                    consumed);
        }
    
        @Override
        public boolean dispatchNestedPreFling(float velocityX, float velocityY) {
            Log.d(TAG, "NestScrollingView  dispatchNestedPreFling");
            return mChildHelper.dispatchNestedPreFling(velocityX,velocityY);
        }
    
        private int lastX;
        private int lastY;
    
        @Override
        public boolean onTouchEvent(MotionEvent event) {
            switch (event.getAction()) {
                case MotionEvent.ACTION_DOWN:
                    Log.d(TAG, "onTouchEvent  ACTION_DOWN ");
                    // 按下事件调用startNestedScroll
                    lastX = (int) event.getX();
                    lastY = (int) event.getY();
                    Log.d(TAG, "onTouchEvent  lastX = "+lastX+"  lasty="+lastY);
                    startNestedScroll(ViewCompat.SCROLL_AXIS_VERTICAL);
                    break;
                case MotionEvent.ACTION_MOVE:
                    Log.d(TAG, "onTouchEvent  ACTION_MOVE ");
    
                    int x = (int) event.getX();
                    int y = (int) event.getY();
    
                    int deltaX = x - lastX;
                    int deltaY = y - lastY;
    
                    Log.d(TAG, "onTouchEvent  x = "+x+"  y="+y);
                    Log.d(TAG, "onTouchEvent  deltaX = "+deltaX+"  deltaY="+deltaY);
    
                    dispatchNestedPreScroll(deltaX,deltaY,mConsumed,mOffset);
    
                    Log.d(TAG, "onTouchEvent  mConsumed[0] = "+mConsumed[0]+"  mConsumed[1] = "+mConsumed[1]);
                    Log.d(TAG, "onTouchEvent  offsetX = " + mOffset[0] + ",offsetY = " + mOffset[1]);
    
                    if(deltaY>mConsumed[1]){
                        setTranslationY(deltaY-mConsumed[1]);
                    }
                    dispatchNestedScroll(0,deltaY,deltaX,0,mOffset);
                    break;
                case MotionEvent.ACTION_UP:
                    Log.d(TAG, "onTouchEvent  ACTION_UP ");
                    stopNestedScroll();
                    break;
                default:
                    break;
            }
            return true;
        }
    }
    

    由于我是在API 24上开发的,所以仅仅要继承View能够,由于View已经实现NestedScrollingChild接口的所有函数,为了安全起见。不妨实现这个接口,事件的開始由子View開始,所以在onTouchEvent()函数里開始和父View一起处理事件。
    父View:相同父View最好也实现NestedScrollingParent接口
    package cj.com.nestedscrollingdemo;
    
    import android.content.Context;
    import android.support.v4.view.NestedScrollingChild;
    import android.support.v4.view.NestedScrollingParent;
    import android.support.v4.view.NestedScrollingParentHelper;
    import android.support.v4.view.ViewCompat;
    import android.util.AttributeSet;
    import android.util.Log;
    import android.view.View;
    import android.widget.FrameLayout;
    
    /**
     *
     */
    
    public class NestScrollingViewGroup extends FrameLayout {
        private NestedScrollingParentHelper mParentHelper;
        private static final String TAG = "Test";
    
        public NestScrollingViewGroup(Context context, AttributeSet attrs) {
            super(context, attrs);
            init();
        }
    
        public NestScrollingViewGroup(Context context) {
            super(context);
            init();
        }
    
        public NestScrollingViewGroup(Context context, AttributeSet attrs, int defStyleAttr) {
            super(context, attrs, defStyleAttr);
            init();
        }
        private void init() {
            mParentHelper = new NestedScrollingParentHelper(this);
        }
    
        @Override
        public boolean onStartNestedScroll(View child, View target, int nestedScrollAxes) {
            Log.d(TAG, "NestScrollingViewGroup  onStartNestedScroll  nestedScrollAxes ="+nestedScrollAxes);
            return (nestedScrollAxes & ViewCompat.SCROLL_AXIS_VERTICAL) != 0;
        }
    
        @Override
        public void onNestedScrollAccepted(View child, View target, int axes) {
            Log.d(TAG, "NestScrollingViewGroup  onNestedScrollAccepted axes="+axes);
            mParentHelper.onNestedScrollAccepted(child, target, axes);
        }
    
        @Override
        public void onStopNestedScroll(View child) {
            Log.d(TAG, "NestScrollingViewGroup  onStopNestedScroll");
            mParentHelper.onStopNestedScroll(child);
        }
    
        @Override
        public void onNestedScroll(View target, int dxConsumed, int dyConsumed, int dxUnconsumed, int dyUnconsumed) {
            Log.d(TAG, "NestScrollingViewGroup  onNestedScroll");
            Log.d(TAG, "    dxConsumed="+dxConsumed+"   dyConsumed="+dyConsumed+"   dxUnconsumed="+dxUnconsumed+"   dyUnconsumed="+dyUnconsumed);
        }
    
        @Override
        public void onNestedPreScroll(View target, int dx, int dy, int[] consumed) {
            Log.d(TAG, "NestScrollingViewGroup  onNestedPreScroll");
            Log.d(TAG, "    dx="+dx+"   dy="+dy+"   consumed[0]="+consumed[0]+"   consumed[1]="+consumed[1]);
    
            if(dy<=80){
                setTranslationY(dy);
                consumed[0] = 0;
                consumed[1] = dy;
            }else{
              //...
                setTranslationY(80);
                consumed[0] = 0;
                consumed[1] = 80;
            }
        }
    
        @Override
        public boolean onNestedFling(View target, float velocityX, float velocityY, boolean consumed) {
            Log.d(TAG, "NestScrollingViewGroup  onNestedFling");
            return super.onNestedFling(target, velocityX, velocityY, consumed);
        }
    
        @Override
        public boolean onNestedPreFling(View target, float velocityX, float velocityY) {
            Log.d(TAG, "NestScrollingViewGroup  onNestedPreFling");
            return super.onNestedPreFling(target, velocityX, velocityY);
        }
    
        @Override
        public int getNestedScrollAxes() {
            Log.d(TAG, "NestScrollingViewGroup  getNestedScrollAxes");
            return mParentHelper.getNestedScrollAxes();
        }
    }
    

    布局文件:
    <?

    xml version="1.0" encoding="utf-8"?

    > <cj.com.nestedscrollingdemo.NestScrollingViewGroup xmlns:android="http://schemas.android.com/apk/res/android" xmlns:tools="http://schemas.android.com/tools" android:background="#f00" android:id="@+id/activity_main" android:layout_width="match_parent" android:layout_height="match_parent" tools:context="cj.com.nestedscrollingdemo.MainActivity"> <cj.com.nestedscrollingdemo.NestScrollingView android:background="#0f0" android:layout_width="300dp" android:layout_height="300dp" /> </cj.com.nestedscrollingdemo.NestScrollingViewGroup>

    看一下log:
    D/Test: NestScrollingView  stopNestedScroll
    D/Test: onTouchEvent  ACTION_DOWN 
    D/Test: onTouchEvent  lastX = 261  lasty=269
    D/Test: NestScrollingView  startNestedScroll
    D/Test: NestScrollingViewGroup  onStartNestedScroll  nestedScrollAxes =2
    D/Test: NestScrollingViewGroup  onNestedScrollAccepted axes=2
    D/Test: onTouchEvent  ACTION_MOVE 
    D/Test: onTouchEvent  x = 264  y=276
    D/Test: onTouchEvent  deltaX = 3  deltaY=7
    D/Test: NestScrollingView  dispatchNestedPreScroll
    D/Test: NestScrollingViewGroup  onNestedPreScroll
    D/Test:     dx=3   dy=7   consumed[0]=0   consumed[1]=0
    D/Test: onTouchEvent  mConsumed[0] = 0  mConsumed[1] = 7
    D/Test: onTouchEvent  offsetX = 0,offsetY = 7
    D/Test: NestScrollingView  dispatchNestedScroll
    D/Test: NestScrollingViewGroup  onNestedScroll
    D/Test:     dxConsumed=0   dyConsumed=7   dxUnconsumed=3   dyUnconsumed=0
    D/Test: onTouchEvent  ACTION_MOVE 
    D/Test: onTouchEvent  x = 261  y=282
    D/Test: onTouchEvent  deltaX = 0  deltaY=13
    D/Test: NestScrollingView  dispatchNestedPreScroll
    D/Test: NestScrollingViewGroup  onNestedPreScroll
    D/Test:     dx=0   dy=13   consumed[0]=0   consumed[1]=0
    D/Test: onTouchEvent  mConsumed[0] = 0  mConsumed[1] = 13
    D/Test: onTouchEvent  offsetX = 0,offsetY = 6
    D/Test: NestScrollingView  dispatchNestedScroll
    D/Test: NestScrollingViewGroup  onNestedScroll
    D/Test:     dxConsumed=0   dyConsumed=13   dxUnconsumed=0   dyUnconsumed=0
    D/Test: onTouchEvent  ACTION_MOVE 
    D/Test: onTouchEvent  x = 258  y=283
    D/Test: onTouchEvent  deltaX = -3  deltaY=14
    D/Test: NestScrollingView  dispatchNestedPreScroll
    D/Test: NestScrollingViewGroup  onNe
    log没贴全然,有点多,通过这一部分就能够知道流程了

    通过一个小demo,能够加深我们对嵌套滑动机制的理解。
    android滑动嵌套应用还是蛮多的。

    比方CoordinatorLayout及子view使用Behavior来实现嵌套滑动。Behavior内部都有NestedScrollingChild。NestedScrollingParent的类似的函数。






  • 相关阅读:
    opencv c++编译
    报bug
    ssh的server安装和安装指定版本的软件的方法
    caffe修改需要的东西 6:40
    caffe修改需要的东西
    leveldb学习:DBimpl
    AndroidStudio加快Gradle速度的方法-android study之旅(103)
    hdu2222--Keywords Search+AC自己主动机模板
    ListView setOnItemClickListener无效原因分析
    Linux打包命令
  • 原文地址:https://www.cnblogs.com/zhchoutai/p/8577959.html
Copyright © 2011-2022 走看看