自定义控件技能——嵌套滑动机制

最新推荐文章于 2021-04-14 22:57:02 发布
最新推荐文章于 2021-04-14 22:57:02 发布
阅读量2.7k 收藏 6
点赞数 1
分类专栏： 自定义控件
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zty19901005/article/details/50974388
版权

Android中的嵌套滑动机制

Android5.0开始提供嵌套滑动机制，用于给子view与父view滑动互动提供更好的交互。
因为在原来的事件分发机制中，如果让子view开始处理事件后，父view有需要在某一个条件下处理事件，只能把子view的事件拦截，在接下来的一个完整的时间系类中，父view就无法继续给子view分发事件了，除非重写dispatchTouchEvent方法，但是我们知道重写这个方法还是比较有难度的。

在最新的V4包等兼容库中Android都对嵌套滑动提供了支持，主要类如下：

V4

  • NestedScrollingParent 嵌套滑动中父view接口
  • NestedScrollingParentHelper 嵌套滑动中父view接口的代理实现
  • NestedScrollingChild 嵌套滑动中子view接口
  • NestedScrollingChildHelper 嵌套滑动中子view接口的代理实现
  • NestedScrollView 支持嵌套滑动的ScrollView

design

  • CoordinatorLayout 协调器布局
  • CoordinatorLayout.Behavior

注意点

  1. 在嵌套滑动中的一些规则：子view是嵌套滑动的发起者，父view是嵌套滑动的处理者
  2. 在使用调用嵌套滑动相关的方法时，应该总是使用：ViewCompat，ViewGroupCompat， ViewParentCompat的静态方法来实现兼容
  3. 应该使用NestedScrollingParentHelper或NestedScrollingChildHelper的对应方法来实现NestedScrollingParent或NestedScrollingChild接口中的方法。

学习嵌套滑动机制

接下来对上述的一些类进行介绍

NestedScrollingChild与NestedScrollingParent

public interface NestedScrollingChild {
    public void setNestedScrollingEnabled(boolean enabled);
    public boolean isNestedScrollingEnabled();
    public boolean startNestedScroll(int axes);
    public boolean hasNestedScrollingParent();
    public boolean dispatchNestedPreScroll(int dx, int dy, int[] consumed, int[] offsetInWindow);
    public boolean dispatchNestedScroll(int dxConsumed, int dyConsumed,
            int dxUnconsumed, int dyUnconsumed, int[] offsetInWindow);
    public boolean dispatchNestedPreFling(float velocityX, float velocityY);
    public boolean dispatchNestedFling(float velocityX, float velocityY, boolean consumed);
    public void stopNestedScroll();



public interface NestedScrollingParent {

    public boolean onStartNestedScroll(View child, View target, int nestedScrollAxes);
    public void onNestedScrollAccepted(View child, View target, int nestedScrollAxes);
    public void onStopNestedScroll(View target);
    public void onNestedScroll(View target, int dxConsumed, int dyConsumed,
            int dxUnconsumed, int dyUnconsumed);
    public void onNestedPreScroll(View target, int dx, int dy, int[] consumed);
    public boolean onNestedFling(View target, float velocityX, float velocityY, boolean consumed);
    public boolean onNestedPreFling(View target, float velocityX, float velocityY);
    public int getNestedScrollAxes();

两个接口都有对应的方法，一个需要被嵌套滑动中的父view实现，一个需要被嵌套滑动中的子view实现。

一个嵌套滑动的完成流程应该是这样的。

  1. 在一个可以滑动的子view中开启嵌套滑动setNestedScrollingEnabled
  2. 如果要开始一次嵌套滑动，首先应该调用startNestedScroll方法(比如在ACTION_DOWN中)，通知父view开始一次嵌套滑动，方法的参数应该是ViewCompatSCROLL_AXIS_HORIZONTAL(横向)或ViewCompatSCROLL_AXIS_VERTICAL(竖向)或者他们的and/or值。这时父view的onStartNestedScroll方法将会被回调，如果父view返回true表示配合此次嵌套滑动，并且父view的onNestedScrollAccepted被调用
  3. 在子view开始滑动之前，应该先问父view许否需要先滑动，也就是调用dispatchNestedPreScroll方法，这个方法接收三个四个参数：
    • dxConsumed 表示子view此次滑动期间将要消耗的水平方法的距离
    • dyConsumed 表示子view此次滑动期间将要消耗的垂直方法的距离
    • consumed 一个两个长度的数组，这个数组传递给父view，如果父view要先行滑动，将会把消耗的距离通过此数据返回给子view
    • offsetInWindow 父view先完成一个滑动后子view在窗口中的偏移值。
    • 上面参数可以理解为：dxConsumed和dyConsumed是总的滑动值，传给父view，如果父view需要滑动有消耗掉一些距离，然后把消耗的距离放在consumed中，返回给子view，返回子view根据父view消耗的距离重新计算自己需要滑动的距离，进行滑动。这个过程发送在父view的onNestedPreScroll方法中。
  4. 子view在根据dispatchNestedPreScroll的返回值，然后计算被父view消耗的距离，根据需要位置
  5. 子view重新计算自己的滑动距离进行滑动之后，需要调用dispatchNestedScroll方法，此方法接收五个参数
    • int dxConsumed 子view在滑动中水平方向消耗的距离
    • int dyConsumed 子view在滑动中垂直方向消耗的距离
    • int dxUnconsumed 子view在滑动中水平方向没有消耗的距离
    • int dyUnconsumed 子view在滑动中垂直方向没有消耗的距离
    • int[] offsetInWindow 返回值。父view完成一个滑动后子view在窗口中的偏移值。
  6. 在完成一系列滑动后，如果需要停止滑动，则子view调用stopNestedScroll然后父view的onStopNestedScroll方法被回调

NestedScrollingParentHelper和NestedScrollingChildHelper分析

NestedScrollingParentHelper和NestedScrollingChildHelper是两个辅助类，分别对象上面分析的两个接口。系统已经给我们封装好了，我们只需要在对应的接口的方法中调用这些辅助类的实现即可。

NestedScrollingChildHelper

public class NestedScrollingChildHelper {
    private final View mView;//嵌套滑动中的子view
    private ViewParent mNestedScrollingParent;//嵌套滑动中的父view接口
    private boolean mIsNestedScrollingEnabled;//嵌套滑动是否可用
    private int[] mTempNestedScrollConsumed;

    public NestedScrollingChildHelper(View view) {
        mView = view;
    }

    //......省略一部分方法

    public boolean startNestedScroll(int axes) {
        if (hasNestedScrollingParent()) {//如果正在进行嵌套滑动，无需处理
            // Already in progress
            return true;
        }
        if (isNestedScrollingEnabled()) {//否则如果嵌套滑动时开启的，遍历查找可以配合嵌套滑动的父view
            ViewParent p = mView.getParent();
            View child = mView;
            while (p != null) {
                if (ViewParentCompat.onStartNestedScroll(p, child, mView, axes)) {//这里调用了父view的onStartNestedScroll询问是否配合嵌套滑动
                //如果配合的话，给mNestedScrollingParent赋值，再调用父view的onNestedScrollAccepted。
                    mNestedScrollingParent = p;
                    ViewParentCompat.onNestedScrollAccepted(p, child, mView, axes);
                    return true;//找到了就返回
                }
                if (p instanceof View) {
                    child = (View) p;
                }
                p = p.getParent();
            }
        }
        return false;
    }

    //停止嵌套滑动，就是调用父view的onStopNestedScroll，然后mNestedScrollingParent置为null
    public void stopNestedScroll() {
        if (mNestedScrollingParent != null) {
            ViewParentCompat.onStopNestedScroll(mNestedScrollingParent, mView);
            mNestedScrollingParent = null;
        }
    }


    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) {//判断输入值

            /*记录子view滑动前在窗口中的位置*/
                int startX = 0;
                int startY = 0;
                if (offsetInWindow != null) {
                    mView.getLocationInWindow(offsetInWindow);
                    startX = offsetInWindow[0];
                    startY = offsetInWindow[1];
                }

                //子view滑动后，告诉父view滑动的距离
                ViewParentCompat.onNestedScroll(mNestedScrollingParent, mView, dxConsumed,
                        dyConsumed, dxUnconsumed, dyUnconsumed);

                if (offsetInWindow != null) {
                 //计算父view滑动后，子view在窗口中的偏移值
                    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;
    }

    //分发嵌套滑动，在子view开始滑动之前
    public boolean dispatchNestedPreScroll(int dx, int dy, int[] consumed, int[] offsetInWindow) {
        if (isNestedScrollingEnabled() && mNestedScrollingParent != null) {
            if (dx != 0 || dy != 0) {//判断 dx 与 dy
                /*记录子view滑动前在窗口中的位置*/
                int startX = 0;
                int startY = 0;
                if (offsetInWindow != null) {
                    mView.getLocationInWindow(offsetInWindow);
                    startX = offsetInWindow[0];
                    startY = offsetInWindow[1];
                }

                if (consumed == null) {//处理==null的情况
                    if (mTempNestedScrollConsumed == null) {
                        mTempNestedScrollConsumed = new int[2];
                    }
                    consumed = mTempNestedScrollConsumed;
                }
                consumed[0] = 0;
                consumed[1] = 0;
                //让父view先滑动。
                ViewParentCompat.onNestedPreScroll(mNestedScrollingParent, mView, dx, dy, consumed);
                //计算父view滑动后，子view在窗口中的偏移值
                if (offsetInWindow != null) {
                    mView.getLocationInWindow(offsetInWindow);
                    offsetInWindow[0] -= startX;
                    offsetInWindow[1] -= startY;
                }
                return consumed[0] != 0 || consumed[1] != 0;//如果父view消耗了一部分距离就返回ture
            } else if (offsetInWindow != null) {
                offsetInWindow[0] = 0;
                offsetInWindow[1] = 0;
            }
        }
        return false;
    }

    public boolean dispatchNestedFling(float velocityX, float velocityY, boolean consumed) {
        if (isNestedScrollingEnabled() && mNestedScrollingParent != null) {
            return ViewParentCompat.onNestedFling(mNestedScrollingParent, mView, velocityX,
                    velocityY, consumed);
        }
        return false;
    }


    public boolean dispatchNestedPreFling(float velocityX, float velocityY) {
        if (isNestedScrollingEnabled() && mNestedScrollingParent != null) {
            return ViewParentCompat.onNestedPreFling(mNestedScrollingParent, mView, velocityX,
                    velocityY);
        }
        return false;
    }

    //......省略一些方法
}

NestedScrollingParentHelper

public class NestedScrollingParentHelper {
    private final ViewGroup mViewGroup;
    private int mNestedScrollAxes;
    public NestedScrollingParentHelper(ViewGroup viewGroup) {
        mViewGroup = viewGroup;
    }

    public void onNestedScrollAccepted(View child, View target, int axes) {
        mNestedScrollAxes = axes;
    }
    public int getNestedScrollAxes() {
        return mNestedScrollAxes;
    }
    public void onStopNestedScroll(View target) {
        mNestedScrollAxes = 0;
    }
}

NestedScrollingParentHelper就是记录NestedScrollAxes。

实战

开始实战之前，我也不知道到底那些消耗值改如何写，但是v4包中有个NestedScrollView可以拿来参考。

然后我们可以可以根据嵌套滑动写一个简单的demo，效果如下：

这里写图片描述

代码实现很简单：

嵌套滑动中的子view：

public class NestChildView extends View implements NestedScrollingChild {

    private static final String TAG = NestChildView.class.getSimpleName();

    private float mLastX;//手指在屏幕上最后的x位置
    private float mLastY;//手指在屏幕上最后的y位置

    private float mDownX;//手指第一次落下时的x位置（忽略）
    private float mDownY;//手指第一次落下时的y位置


    private int[] consumed = new int[2];//消耗的距离
    private int[] offsetInWindow = new int[2];//窗口偏移


    private NestedScrollingChildHelper mScrollingChildHelper;

    public NestChildView(Context context) {
        this(context, null);
    }

    public NestChildView(Context context, AttributeSet attrs) {
        this(context, attrs, 0);
    }

    public NestChildView(Context context, AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
        init();
    }

    private void init() {
        mScrollingChildHelper = new NestedScrollingChildHelper(this);
        setNestedScrollingEnabled(true);
    }


    @Override
    public boolean onTouchEvent(MotionEvent ev) {
        float x = ev.getX();
        float y = ev.getY();

        int action = ev.getAction();

        switch (action) {
            case MotionEvent.ACTION_DOWN: {

                mDownX = x;
                mDownY = y;
                mLastX = x;
                mLastY = y;
                //当开始滑动的时候，告诉父view
                startNestedScroll(ViewCompat.SCROLL_AXIS_HORIZONTAL | ViewCompat.SCROLL_AXIS_VERTICAL);
                break;
            }

            case MotionEvent.ACTION_MOVE: {
                /*
                mDownY:293.0
                mDownX:215.0
                 */

                int dy = (int) (y - mDownY);
                int dx = (int) (x - mDownX);

                //分发触屏事件给父类处理
                if (dispatchNestedPreScroll(dx, dy, consumed, offsetInWindow)) {
                    //减掉父类消耗的距离
                    dx -= consumed[0];
                    dy -= consumed[1];
                    Log.d(TAG, Arrays.toString(offsetInWindow));
                }

                offsetTopAndBottom(dy);
                offsetLeftAndRight(dx);


                break;
            }

            case MotionEvent.ACTION_UP: {
                stopNestedScroll();
                break;
            }
        }
        mLastX = x;
        mLastY = y;
        return true;
    }


    @Override
    public void setNestedScrollingEnabled(boolean enabled) {
        mScrollingChildHelper.setNestedScrollingEnabled(enabled);
    }

    @Override
    public boolean isNestedScrollingEnabled() {
        return mScrollingChildHelper.isNestedScrollingEnabled();

    }

    @Override
    public boolean startNestedScroll(int axes) {
        return mScrollingChildHelper.startNestedScroll(axes);
    }

    @Override
    public void stopNestedScroll() {
        mScrollingChildHelper.stopNestedScroll();

    }

    @Override
    public boolean hasNestedScrollingParent() {
        return mScrollingChildHelper.hasNestedScrollingParent();
    }

    @Override
    public boolean dispatchNestedScroll(int dxConsumed, int dyConsumed, int dxUnconsumed, int dyUnconsumed, int[] offsetInWindow) {
        return mScrollingChildHelper.dispatchNestedScroll(dxConsumed, dyConsumed, dxUnconsumed, dyUnconsumed, offsetInWindow);
    }

    /**
     * @param dx       水平滑动距离
     * @param dy       垂直滑动距离
     * @param consumed 父类消耗掉的距离
     * @return
     */
    @Override
    public boolean dispatchNestedPreScroll(int dx, int dy, int[] consumed, int[] offsetInWindow) {
        return mScrollingChildHelper.dispatchNestedPreScroll(dx, dy, consumed, offsetInWindow);
    }

    @Override
    public boolean dispatchNestedFling(float velocityX, float velocityY, boolean consumed) {
        return mScrollingChildHelper.dispatchNestedFling(velocityX, velocityY, consumed);
    }

    @Override
    public boolean dispatchNestedPreFling(float velocityX, float velocityY) {
        return mScrollingChildHelper.dispatchNestedPreFling(velocityX, velocityY);
    }


}

嵌套滑动中的父view：

public class NestParentLayout extends FrameLayout implements NestedScrollingParent {

    private static final String TAG = NestParentLayout.class.getSimpleName();
    private NestedScrollingParentHelper mScrollingParentHelper;

    public NestParentLayout(Context context) {
        this(context, null);
    }

    public NestParentLayout(Context context, AttributeSet attrs) {
        this(context, attrs, 0);
    }

    public NestParentLayout(Context context, AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
        mScrollingParentHelper = new NestedScrollingParentHelper(this);
    }


    /*
    子类开始请求滑动
     */
    @Override
    public boolean onStartNestedScroll(View child, View target, int nestedScrollAxes) {
        Log.d(TAG, "onStartNestedScroll() called with: " + "child = [" + child + "], target = [" + target + "], nestedScrollAxes = [" + nestedScrollAxes + "]");

        return true;
    }


    @Override
    public void onNestedScrollAccepted(View child, View target, int axes) {
        mScrollingParentHelper.onNestedScrollAccepted(child, target, axes);
    }


    @Override
    public int getNestedScrollAxes() {
        return mScrollingParentHelper.getNestedScrollAxes();
    }

    @Override
    public void onStopNestedScroll(View child) {
        mScrollingParentHelper.onStopNestedScroll(child);
    }

    @Override
    public void onNestedPreScroll(View target, int dx, int dy, int[] consumed) {
        Log.d(TAG, "onNestedPreScroll() called with: " + "dx = [" + dx + "], dy = [" + dy + "], consumed = [" + Arrays.toString(consumed) + "]");
        final View child = target;
        if (dx > 0) {
            if (child.getRight() + dx > getWidth()) {
                dx = child.getRight() + dx - getWidth();//多出来的
                offsetLeftAndRight(dx);
                consumed[0] += dx;//父亲消耗
            }


        } else {
            if (child.getLeft() + dx < 0) {
                dx = dx + child.getLeft();
                offsetLeftAndRight(dx);
                Log.d(TAG, "dx:" + dx);
                consumed[0] += dx;//父亲消耗
            }


        }

        if (dy > 0) {
            if (child.getBottom() + dy > getHeight()) {
                dy = child.getBottom() + dy - getHeight();
                offsetTopAndBottom(dy);
                consumed[1] += dy;
            }
        } else {
            if (child.getTop() + dy < 0) {
                dy = dy + child.getTop();
                offsetTopAndBottom(dy);
                Log.d(TAG, "dy:" + dy);
                consumed[1] += dy;//父亲消耗
            }
        }


    }
}
ZtianyAndroid
关注
  • 1
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
自定义View事件篇进阶篇(二)-自定义NestedScrolling实战
Andy博客
07-29 403
slice.jpg 前言 在上篇文章自定义View事件之进阶篇(一)-NestedScrolling(嵌套滑动)机制中，我们分析了谷歌对NestedScrolling机制的设计，了解的不同接口的使用场景。现在就让我们一起结合一个实际的使用例子，来巩固之前学习的知识点吧。 效果展示 先看我们需要仿写的实际效果吧。如下图所示： demo展...
Android NestedScrolling机制完全解析 带你玩转嵌套滑动
最新发布
2301_79056696的博客
04-14 468
其实Android开发的知识点就那么多，面试问来问去还是那么点东西。所以面试没有其他的诀窍，只看你对这些知识点准备的充分程度。so，出去面试时先看看自己复习到了哪个阶段就好。上面分享的百度、腾讯、网易、字节跳动、阿里等公司2021年的高频面试题，博主还把这些技术点整理成了视频和PDF（实际上比预期多花了不少精力），包含知识脉络 + 诸多细节，由于篇幅有限，上面只是以图片的形式给大家展示一部分。【Android思维脑图（技能树）】知识不体系？
NestedScrolling机制解析(一)——从NestedScrollingParent和NestedScrollingChild分析入手
VictorCatFish的博客
12-11 1338
NestedScrolling机制概述 我们知道，在Android系统对于Touch事件有一套自己的分发机制，其中主要涉及到以下三个方法： dispatchTouchEvent()：主要是在View和ViewGroup中进行事件分发 onInterceptTouchEvent()：进行Touch事件的拦截 onTouchEvent()：Touch事件的处理 事件分发...
Android中的NestedScrollingParent和NestedScrollingChild分析
樱落山庄
07-11 8491
在分析SwipeRefreshLayout源码的时候发现该类实现了NestedScrollingParent和NestedScrollingChild两个接口,甚是好奇,于是结合了网上的资料,然后根据我个人的理解写下本章. 这个两个接口是为了更好解决事件冲突的. 在这里 nested scrolling 就翻译为嵌套滚动吧. 但是这和以前用过的dispatchTouchEvent,onInte
CoordinatorLayout与ListView协同让FAB悬浮按钮从底部消失及出现
Widsom的博客
05-10 6674
CoordinatorLayout协同布局在一般只结合RecyclerView和NestedScrollView使用，如果我使用ListView没有效果的。但是，由于业务原因使用ListView，有需要实现协同的效果怎么办？其实分析RecyclerView和NestedScrollView的源码可以知道，他们都实现了一个接口NestedScrollingChild，所以我们可以自定义ListView
自定义View：嵌套滑动深入理解
临木的博客
04-14 1511
本文主要探讨以下几个问题： 嵌套滑动设计目的 嵌套滑动的实现 嵌套滑动与事件分发机制 嵌套滑动设计目的 不知道大家有没有注意过淘宝APP首页的二级联动，滑动的商品的时候上面类别也会滑动，滑动过程中类别模块停了商品还能继续滑动。也就是说滑动的是view，ViewGroup也会跟着滑动。如果用事件分发机制处理也能处理，但会及其麻烦。那用NestedScroll会咋样？ 嵌套滑动的实现 事件分发 ...
安卓Android源码——安卓Android 自定义头部控件,简单易用.zip
10-10
在安卓应用开发中，自定义控件是提升用户体验和实现独特设计的重要手段。标题"安卓Android源码——安卓Android 自定义头部控件,简单易用...通过实际操作，你可以加深对Android自定义控件的理解，并提升自己的开发技能。
安卓Android源码——ViewFlipper水平滑动.zip
10-11
本资源"安卓Android源码——ViewFlipper水平滑动.zip"包含了对ViewFlipper控件的深入理解和实践，特别是针对水平滑动功能的实现。 首先，我们来看`MyAndroidFlip`这个项目，它很可能是一个包含ViewFlipper示例的...
安卓Android源码——UITableViewios风格控件.zip
10-11
这个压缩包“安卓Android源码——UITableViewios风格控件.zip”包含了一个名为“android-uitableview-master”的项目，旨在复现iOS的UITableView在Android上的效果。下面，我们将深入探讨如何在Android中创建一个...
Android下拉刷新控件SwipeRefreshLayout源码解析
09-01
本文将深入解析`SwipeRefreshLayout`的源码，帮助开发者更好地理解和使用这个控件。 首先，`SwipeRefreshLayout`继承自`ViewGroup`，这意味着它可以包含一个子视图，并处理触摸事件。其核心功能在于监听用户的滑动...
安卓Android源码——-整体UI设计（滑动导航栏+滚动页面）.zip
10-14
`ScrollView`是一个可容纳单个直接子视图的容器，而`NestedScrollView`则支持嵌套滑动，更适合在复杂的布局结构中使用。开发者可以将多个视图如`TextView`, `ImageView`等放入`ScrollView`内，确保用户可以浏览所有...
Android自定义控件之实现滑动选择开关代码
05-30
Android自定义控件之实现滑动选择开关
Android嵌套滑动简介——手把手教你打造黏性头部控件
ljcmeng的博客
01-01 3515
Android嵌套滑动简介——手把手教你打造黏性头部控件问题的引入接口简介嵌套滑动实战关于嵌套滑动踩过的坑以及误区 问题的引入 首先让我们看一个效果: 在很早之前, 我们想实现上面这个效果的通常做法是自己写一个ViewGroup, 拦截下触摸事件, 控制里面滑动事件的分发. 如果第一个view已经滑出屏幕,则把剩下的事件交给recyclerview处理. 处理过的同学们都知道, 分发复杂,还要考...
android 可滑动组件互相嵌套时滑动冲突解决方案总结
scry5566的专栏
08-24 1733
参考文章： http://www.jianshu.com/p/87a41b8c0dd0 http://www.jianshu.com/p/8bc0765dffc9   强烈推荐使用以上两篇文章的方法。          以下是我个人在项目中的解决方案，比较LOW，现在不建议使用，但可作为一种知识参考。          本人自己以前都是重写ScrollView,ListV
Android 自定义 ViewGroup(二) 定义最上层 ViewGroup 并解决多层滑动嵌套冲突与多点触摸滑动
u012216274的博客
04-07 3627
自己再定义最上层的滑动控件,再去嵌套google提供的类似ViewPager,ListView,ScrollView,HorizontalScrollView，RecyclerView这些即有横向又有纵向的滑动控件时,就要自己去处理滑动冲突了,这时候就要深入了解android的滑动嵌套时如何解决滑动冲突的原理了
Android 嵌套滑动——NestedScrolling完全解析
茅屋
10-25 2085
基本的事件分发流程对于一次从父布局到自布局的触摸事件流程分发，关键便是在三个方法上的流程处理dispatchTouchEvent(),onInterceptTouchEvent(),onTouchEvent()。由于和NestScroll相关，所以不细致分析到View层面上的事件分发。对于事件分发的触摸大致可分为按下（DOWN），移动（MOVE），抬起（UP）。按照这三个事件，流程分析如下： 按下（
嵌套滑动机制详解
lxj1137800599的专栏
01-24 812
嵌套滑动机制主要涉及两个接口 public interface NestedScrollingChild { void setNestedScrollingEnabled(boolean var1); boolean isNestedScrollingEnabled(); boolean startNestedScroll(int var1);//开启嵌套滚动流程
ViewPager，ScrollView 嵌套ViewPager滑动冲突解决
热门推荐
徐公，微信公众号同名
10-26 3万+
ViewPager，ScrollView 嵌套ViewPager滑动冲突解决这篇博客主要讲解一下几个问题 - 粗略地介绍一下View的事件分发机制 - 解决事件滑动冲突的思路及方法 - ScrollView 里面嵌套ViewPager导致的滑动冲突 - ViewPager里面嵌套ViewPager 导致的滑动冲突 - 轮播图的几种实现方式先看一下效果图ScrollView里面嵌套View
一步一步教你自定义控件——01
09-12
自定义控件是Android开发中常见的任务之一。下面是一步一步教你如何自定义控件的简要指南： 第一步：创建一个新的Java类作为你的自定义控件。 首先，创建一个新的Java类，可以命名为你想要的控件名称。这个类应该继承自Android框架中的现有控件，例如View、TextView等。例如，如果你想要创建一个自定义按钮，可以创建一个名为CustomButton的类，并让它继承自Button类。 第二步：实现构造函数和属性。 在你的自定义控件类中，你可以实现构造函数和属性，以便对控件进行初始化和设置。你可以定义自己的属性，例如颜色、大小等，以及相应的getter和setter方法。 第三步：重写绘制方法。 要自定义控件的外观，你需要重写它的绘制方法。最常用的方法是重写`onDraw()`方法，在其中使用Canvas绘制你想要的形状、文本等。 第四步：处理用户交互。 如果你的自定义控件需要与用户进行交互，你可以重写相应的触摸事件（例如`onTouchEvent()`）或点击事件（例如`setOnClickListener()`）来处理用户操作。 第五步：在布局文件中使用自定义控件。 完成以上步骤后，你可以在布局文件中使用你的自定义控件了。只需在布局文件中添加一个与你的控件类名相对应的XML标签，并设置相应的属性。 这只是一个简要的指南，帮助你开始自定义控件的过程。在实际开发中，你可能需要更多的步骤和细节来完成你的自定义控件。你可以参考Android官方文档或其他教程来获取更多信息和示例代码。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值