关闭

基于view的复用的自定义横向滚动的Viewgroup

标签: viewgroup
208人阅读 评论(0) 收藏 举报
分类:

首先特别感谢http://blog.csdn.net/mtaxot/article/details/51446083,这个代码就是在他的代码上改的,

package com.baidu.baike;

import android.content.Context;
import android.database.DataSetObserver;
import android.graphics.Rect;
import android.support.v4.view.ViewCompat;
import android.util.AttributeSet;
import android.view.GestureDetector;
import android.view.MotionEvent;
import android.view.View;
import android.view.ViewGroup;
import android.widget.ListAdapter;
import android.widget.Scroller;

import java.util.LinkedList;

public class HorizontalScrollView extends ViewGroup {
    // ===========================================================
    // Constants
    // ===========================================================

    //这两个常量是为ViewGroup.addViewInLayout(View, int, LayoutParams, boolean)
    //准备的,第二个参数如果为-1表示尾插,0表示头插
    private static final int INSERT_AT_END_OF_LIST = -1;
    private static final int INSERT_AT_START_OF_LIST = 0;

    // ===========================================================
    // Fields
    // ===========================================================

    /**
     * 用于计算fling时滑动dx的Scroller,会根据你的滑动,为你计算出下一个滚动位置
     */
    protected Scroller mScroller = new Scroller(getContext());

    /**
     * 检测fling等操作的回调
     */
    private final GestureListener mGestureListener = new GestureListener();

    /**
     * 检测fling等操作
     */
    private GestureDetector mDetector;

    /**
     * 记录最左边可见的那个View从什么位置开始展示
     * 取值范围0到-view.getWidth()
     * 其实就是我们layout的时候需要用到的那个offset
     **/
    private int mLeftVisibleViewDisplayOffset;

    /**
     * 适配器
     */
    protected ListAdapter mAdapter;

    /**
     * 回收,缓存View的队列
     */
    private LinkedList<View> mViewsCache = new LinkedList<>();

    /**
     * 标记数据集改变,你对notifyDataSetChanged一定不陌生
     */
    private boolean mDataSetChanged = false;

    /**
     * 用来帮助计算坐标(x,y)所在的item
     */
    private Rect mRect = new Rect();
    /**
     * 这个值以像素为单位,是最重要的一个值,记录当前滑动的距离里
     * 取值范围是0-最大滑动距离,也就是最后一个Item完全显示出来的时候,永远是正数
     */
    protected int mCurrentScrollX;

    /**
     * 滑动的过程是平滑的,这需要保存下一个滚动的位置,一般地, mCurrentScrollX和mNextScrollX相差很小,
     * 这样重绘UI的时候才会觉得平滑,mNextScrollX可以通过Scroller计算,亦可以通过GestureListener 计算得到,
     * 不滑动的时候mNextScrollX等于mCurrentScrollX
     */
    protected int mNextScrollX;

    /**
     * 记录最大的滚动距离,也就是最后一个item完全显示出来的时候的滚动距离。
     * 这个值没有办法初始化,只能在滑动的过程中动态计算,且一旦计算完成就不需要再计算,除非布局发生改变
     */
    private int mMaxScrollX = Integer.MAX_VALUE;

    /**
     * 最左边的View在adapter中的索引
     */
    private int mLeftVisibleViewAdapterIndex;

    /**
     * 最右边的View在adapter中的索引
     */
    private int mRightVisibleViewAdapterIndex;
    // ===========================================================
    // Constructors
    // ===========================================================

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

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

    public HorizontalScrollView(Context context, AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
        mDetector = new GestureDetector(context, mGestureListener);//手势检测
        initView();
    }

    // ===========================================================
    // Public Methods
    // ===========================================================

    /**
     * 给adapter赋值
     */
    public void setAdapter(ListAdapter adapter) {
        if (mAdapter != null) {
            mAdapter.unregisterDataSetObserver(mAdapterDataObserver);
        }
        if (adapter != null) {
            mAdapter = adapter;
            mAdapter.registerDataSetObserver(mAdapterDataObserver);
        }
        reset();
    }

    /**
     * 根据坐标返回item的位置
     */
    public int getChildIndex(final int x, final int y) {
        int childCount = getChildCount();

        for (int index = 0; index < childCount; index++) {
            getChildAt(index).getHitRect(mRect);
            if (mRect.contains(x, y)) {
                return index;
            }
        }
        return -1;
    }




    // ===========================================================
    // Methods for/from SuperClass/Interfaces
    // ===========================================================


    /**
     * 控件消除的时候接触观察者的监听
     */
    @Override
    protected void onDetachedFromWindow() {
        if (mAdapter != null)
            mAdapter.unregisterDataSetObserver(mAdapterDataObserver);
        super.onDetachedFromWindow();
    }
    /**
     * 核心逻辑在这里。。。。。
     * 为了让滑动生效,我们需要每滑动一小段距离,或是fling一小段距离,就需要调用一下requestLayout来
     * 触发本方法执行,直到滑动结束或是fling完毕,
     */
    @Override
    protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
        if (mAdapter == null) {
            return;
        }
        // 如果数据改变
        if (mDataSetChanged) {
            int oldCurrentX = mCurrentScrollX;
            initView();
            removeAllViewsInLayout();
            mNextScrollX = oldCurrentX;// mCurrentX is 0 now.
            mDataSetChanged = false;
        }
        //做一个简单的非法值校验
        //滑到最左边或最右边就强制停止fling
        if (mNextScrollX <= 0) {
            mNextScrollX = 0;
            mScroller.forceFinished(true);
        } else if (mNextScrollX >= mMaxScrollX) {
            mNextScrollX = mMaxScrollX;
            mScroller.forceFinished(true);
        }
        //计算滑动的变化量,向左滑动 dx < 0  向右滑动 dx > 0
        int dx = mCurrentScrollX - mNextScrollX;
        mCurrentScrollX = mNextScrollX;
        removeNonVisibleChildren(dx);
        fillList(dx);
        positionChildren(dx);
        //滑动的过程当中,尝试计算mMaxScrollX
        measuerMaxScrollX();
        //如果惯性滑动没有停止,就低轨道调用onLayuout计算,直到停止
        if (!mScroller.isFinished()) {
            //递归调用onLayout
            ViewCompat.postOnAnimation(this, mDelayedLayout);

        }
    }

    /**
     * 控制滚动的方法
     */
    @Override
    public void computeScroll() {
        //这个方法会帮你计算下一个要滑动的位置,Scroller如何使用,自己去查查
        if (mScroller.computeScrollOffset()) {
            // Compute the next position
            mNextScrollX = mScroller.getCurrX();
        }
    }

    /**
     * 检测到fling事件,启动scroller,并且触发onLayout,就会触发整个fling操作
     */
    protected boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX, float velocityY) {
        mScroller.fling(mNextScrollX, 0, (int) -velocityX, 0, 0, mMaxScrollX, 0, 0);
        requestLayout();
        return true;
    }

    protected boolean onDown(MotionEvent e) {
        //滑动过程中,只要触摸就停止滑动
        mScroller.forceFinished(true);
        return true;
    }

    @Override
    public boolean onTouchEvent(MotionEvent event) {
        mDetector.onTouchEvent(event);
        return true;
    }


    // ===========================================================
    // Private Methods
    // ===========================================================

    /**
     * 初始化默认值
     */
    private void initView() {
        mLeftVisibleViewAdapterIndex = -1;
        mRightVisibleViewAdapterIndex = -1;
        mLeftVisibleViewDisplayOffset = 0;
        mCurrentScrollX = 0;
        mNextScrollX = 0;
        mMaxScrollX = Integer.MAX_VALUE;
    }

    /**
     * 重置默认值
     */
    private void reset() {
        initView();
        removeAllViewsInLayout();
        requestLayout();
    }

    /**
     * ListView也使用这个,可以到源码里看一下,继承的层次略深
     */
    private DataSetObserver mAdapterDataObserver = new DataSetObserver() {
        @Override
        public void onChanged() {
            mDataSetChanged = true;
            // 数据集改变,我们就重绘自己
            invalidate();
            requestLayout();
        }

        @Override
        public void onInvalidated() {
            reset();
            invalidate();
            requestLayout();
        }
    };

    /**
     * 得到缓存的view的第一个
     */
    private View getRecycledView() {
        if (mViewsCache.size() != 0) {
            return mViewsCache.removeFirst();
        }
        return null;
    }

    /**
     * 添加到缓存
     */
    private void recycleView(View view) {
        mViewsCache.addLast(view);
    }

    /**
     * 将一个view放置到HorizontalListView里,但是View只被测量了,没有被layout 和draw
     */
    private void addAndMeasureChild(final View child, int viewPos) {
        LayoutParams params = child.getLayoutParams();
        if (params == null) {
            params = new LayoutParams(LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT);
        }
        addViewInLayout(child, viewPos, params, true);
        final int itemHeight = getHeight();
        child.measure(MeasureSpec.UNSPECIFIED, MeasureSpec.EXACTLY | itemHeight);
    }


    /**
     * 用来递归调用onLayout方法
     */
    private Runnable mDelayedLayout = new Runnable() {
        @Override
        public void run() {
            requestLayout();
        }
    };

    /**
     * 用来测量最大的滚动距离
     * 也就最后一个child的右边界x坐标减去父控件的宽度(一般都是屏幕的宽度)
     */
    private void measuerMaxScrollX() {
        //只有最后一个,也是最右边的item滑入屏幕的时候才计算mMaxScrollX
        if (mRightVisibleViewAdapterIndex == mAdapter.getCount() - 1) {
            View rightView = getChildAt(getChildCount() - 1);
            if (rightView != null) {
                mMaxScrollX = mCurrentScrollX + rightView.getRight() - getWidth();
                if (mMaxScrollX < 0) {
                    mMaxScrollX = 0;
                }
            }
        }
    }

    /**
     * 添加view
     */
    private void fillList(final int dx) {
        // 从右边添加
        int edge = 0;
        View child = getChildAt(getChildCount() - 1);
        if (child != null) {
            edge = child.getRight();
        }
        fillListRight(edge, dx);//如果最右边空了,就填充,直到最右边填满屏幕为止

        // 从左边添加
        edge = 0;
        child = getChildAt(0);
        if (child != null) {
            edge = child.getLeft();
        }
        //如果最左边空了,就填充,直到最左边填满屏幕为止
        fillListLeft(edge, dx);
    }

    /**
     * 移除view
     */
    private void removeNonVisibleChildren(final int dx) {
        View child = getChildAt(0);
        //移除左边的滑出屏幕的view,直到最左边的view还可见,就停止
        while (child != null && child.getRight() + dx <= 0) {
            mLeftVisibleViewDisplayOffset += child.getMeasuredWidth();
            recycleView(child);
            removeViewInLayout(child);
            mLeftVisibleViewAdapterIndex++;
            child = getChildAt(0);
        }

        child = getChildAt(getChildCount() - 1);
        //移除右边的滑出屏幕的view,直到最右边的view还可见,就停止
        while (child != null && child.getLeft() + dx >= getWidth()) {
            recycleView(child);
            removeViewInLayout(child);
            mRightVisibleViewAdapterIndex--;
            child = getChildAt(getChildCount() - 1);
        }
    }

    /**
     * 从右边填充
     */
    private void fillListRight(int rightEdge, final int dx) {
        while (rightEdge + dx < getWidth() && mRightVisibleViewAdapterIndex + 1 < mAdapter.getCount()) {
            mRightVisibleViewAdapterIndex++;
            if (mLeftVisibleViewAdapterIndex < 0) {
                mLeftVisibleViewAdapterIndex = mRightVisibleViewAdapterIndex;
            }
            //我们写的adapter的getView,第一个参数是position,第二个参数是convertView,第三个参数是ViewGroup
            View child = mAdapter.getView(mRightVisibleViewAdapterIndex, getRecycledView(), this);
            addAndMeasureChild(child, INSERT_AT_END_OF_LIST);
            rightEdge += child.getMeasuredWidth();

        }
    }

    /**
     * 从左边填充
     */
    private void fillListLeft(int leftEdge, final int dx) {
        while (leftEdge + dx > 0 && mLeftVisibleViewAdapterIndex >= 1) {
            mLeftVisibleViewAdapterIndex--;
            View child = mAdapter.getView(mLeftVisibleViewAdapterIndex, getRecycledView(), this);
            addAndMeasureChild(child, INSERT_AT_START_OF_LIST);
            leftEdge -= child.getMeasuredWidth();
            mLeftVisibleViewDisplayOffset -= child.getMeasuredWidth();
        }
    }

    /**
     * 这个方法就是item的摆放逻辑了,从做摆放到右,用到mLeftVisibleViewDisplayOffset这个值
     * 这里需要强调一下,layout的过程,可用的宽度只有屏幕的大小,这个坐标也是相对于屏幕的
     * 而mCurrentScrollX则是逻辑上的,其实这个逻辑就是,将item整体移动dx具体,可能向左,可能向右,取决于dx的正负
     */
    private void positionChildren(final int dx) {
        int childCount = getChildCount();
        if (childCount > 0) {
            mLeftVisibleViewDisplayOffset += dx;
            int left = mLeftVisibleViewDisplayOffset;
            for (int i = 0; i < childCount; i++) {
                View child = getChildAt(i);
                int right = child.getMeasuredWidth();
                int bottom = child.getMeasuredHeight();
                child.layout(left, 0, left + right, bottom);
                left += child.getMeasuredWidth();
            }
        }
    }

    // ===========================================================
    // Inner and Anonymous Classes
    // ===========================================================


    private class GestureListener extends GestureDetector.SimpleOnGestureListener {
        @Override
        public boolean onDown(MotionEvent e) {
            return HorizontalScrollView.this.onDown(e);
        }

        @Override
        public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX, float velocityY) {
            return HorizontalScrollView.this.onFling(e1, e2, velocityX, velocityY);
        }

        @Override
        public boolean onScroll(MotionEvent e1, MotionEvent e2, float distanceX, float distanceY) {
            //触摸滚动的时候,计算mNextScrollX,然后触发onLayout进行重绘,触摸滑动停止,重新布局停止
            mNextScrollX += (int) distanceX;
            requestLayout();
            return true;
        }

        @Override
        public boolean onSingleTapConfirmed(MotionEvent e) {
            return false;
        }

        @Override
        public void onLongPress(MotionEvent e) {

        }
    }


}

0
0
查看评论

ScrollerLayout——可横向滚动的自定义viewgroup

具体功能看效果图: 如何录屏小贴士 使用手机自带的录屏软件,录制后卫MP4格式,在使用下面这个网址介绍的方法,转为gif(我是用的是在线转的那个,挺好用) Android手机如何录制屏幕及转GIF 这个自定义控件涉及到的知识点: 自定义ViewGroup中onMeasure和onLay...
  • Android_Study_OK
  • Android_Study_OK
  • 2016-05-09 11:20
  • 2110

自定义ViewGroup实现垂直滚动

转载请表明出处:http://write.blog.csdn.net/postedit/23692439 一般进入APP都有欢迎界面,基本都是水平滚动的,今天和大家分享一个垂直滚动的例子。 先来看看效果把: 1、首先是布局文件: [ht...
  • gebitan505
  • gebitan505
  • 2014-05-30 15:40
  • 4652

自定义ViewGroup学习(LinearLayout的布局方式,可以滚动和嵌套)

自定义ViewGroup学习(LinearLayout的布局方式,可以滚动和嵌套) 首先先看效果图 自定义ViewGroup,必须重写onLayout()方法 当然,还需要onMeasure() 下边就是最基本的 public class MyViewGroup extends V...
  • xiaoguiyixue
  • xiaoguiyixue
  • 2016-07-07 14:27
  • 1690

自定义 ViewGroup 支持无限循环翻页之一(重写 onLayout以及 dispatchDraw)

之前由于公司产品需求,需要一个可以无限
  • kifile
  • kifile
  • 2014-10-25 15:29
  • 1959

Android自定义ViewGroup实现水平排列样式(1)

Android自定义ViewGroup:onMeasure与onLayout(1)             先看一下效果图          ...
  • qingxuan521721
  • qingxuan521721
  • 2017-12-08 16:22
  • 79

对比自定义view和自定义viewgroup

view 的onDraw()和ViewGroup的dispatchDraw()方法最近在研究view的整个事件过程,以及自定义view的绘制,今天突然发现还有dispatchDraw(),于是在官方api中找到了draw()方法。通常我们自定义一个view只需要先测量,然后定位置,位置确定了就可以开...
  • outdoorsmanm
  • outdoorsmanm
  • 2016-03-17 18:35
  • 1422

自定义ViewGroup和其子View

ViewGroup 初始化计算width,height。顺序如下05-13 13:41:57.649 D/GestureLockFred(32644): onMeasure 05-13 13:41:57.649 D/GestureLockFred(32644): onMeasure 05-13 ...
  • laisse
  • laisse
  • 2016-05-18 11:57
  • 1617

View和ViewGroup的区别以及自定义控件步骤小结

1.他们都需要进行测量操作 2.ViewGroup主要是控制子view如何摆放,所以必须实现onLayout   View没有子view,所以不需要onLayout方法,但是必须实现onDraw 自定义控件步骤: 测量:onMeasure  设置自己显示在屏幕上的宽高 布局...
  • rentalphang
  • rentalphang
  • 2016-06-22 22:45
  • 909

Android自定义View或ViewGroup的流程

对于onMeasure()方法-->不论是View还是ViewGroup,onMeasure方法其实都是在测量自身的宽和高,只是对于ViewGroup来讲,当该ViewGroup的父容器为其设置的计算模式不是MeasureSpec.EXACTLY时(即自己设置的是wrap_content),该...
  • shakespeare001
  • shakespeare001
  • 2016-04-07 21:09
  • 1498

了解自定义View和继承View,继承ViewGroup,继承已有View,继承已有ViewGroup实例ji

自定义View的分类 继承View 当我们需要实现的效果是一个不规则效果的时候,那么这时就需要继承 View 来实现了,我们需要重写 onDraw 方法,在该方法里实现各种不规则的图形和效果。当我们使用这种方式的时候,需要自己去处理 warp_content 和 padding。 继承Vi...
  • github_37217206
  • github_37217206
  • 2017-02-06 10:25
  • 709
    个人资料
    • 访问:26390次
    • 积分:750
    • 等级:
    • 排名:千里之外
    • 原创:50篇
    • 转载:5篇
    • 译文:0篇
    • 评论:11条
    文章分类
    最新评论