Android 自定义布局竖向的ViewPager的实现

android 自定义布局竖向的viewpager的实现

效果图：

这个自定义控件涉及到的知识点：

自定义viewgroup中onmeasure和onlayout的写法
弹性滚动scroller的用法
速度轨迹追踪器velocitytracker的用法
如何处理滑动事件冲突

dispatchtouchevent：（外部拦截）告诉此scrolllayout的父布局，什么时候该拦截触摸事件，什么时候不该拦截触摸事件

onintercepttouchevent：（内部拦截）scrolllayout告诉自己什么时候要拦截内部子view的触摸事件，什么时候不要拦截内部子view的触摸事件

处理触摸滑动的思路：

1. 先实现布局跟着手指的滑动而滑动 scrollby
2. 处理好边界条件（这次的处理边界，仅适用于低速滑动情况下）
3. 如果是快速滑动velocitytracker，必须再次考虑边界问题（上面考虑的边界问题不适用于快速滑动情况）
4. 如果是低速滑动，要根据手指滑动方向和布局滑动的距离一起做判断，来确定，页面该滑动到那个页面，这里用到了弹性滑动scroller
5. 难点来了：算法，

//即确定当前显示的子控件的位置，
//确定弹性滑动滑向那个位置 
if (math.abs(velocityy) > criticalvelocityy) {//当手指滑动速度快时，按照速度方向直接翻页 
// 重点二、快速滑动时，如何判断当前显示的是第几个控件，并且再次包含边界判断（必须包含边界判断，因为前面的边界判断，只适用于低速滑动时） 
if (shouzhixiangxiahuadong) { 
if (currentpage > 1) {//★★★★★★★★边界限制，防止滑倒第一个，还继续滑动，注意★（currentpage-2） 
mscroller.startscroll(0, getscrolly(), 0, childheight * (currentpage - 2) - getscrolly()); 
currentpage--; 
} 
} else { 
if (currentpage < childcount) {//★★★★★★★边界限制，防止滑倒最后一个，还继续滑动，注意★currentpage 
mscroller.startscroll(0, getscrolly(), 0, childheight * currentpage - getscrolly()); 
currentpage++; 
} 
} 
log.e("eee", currentpage + "");

总结

当要写一个算法时，不要着急试图一下子写出来，这样往往陷入盲目，应该是一步一步地推导，一步一步实现代码，指导最后找到规律，类似于归纳总结、通项公式的方法。

代码如下：（注释很全）

package beautlful.time.com.beautlfultime.view;

import android.content.context;
import android.support.v4.view.viewconfigurationcompat;
import android.util.attributeset;
import android.util.log;
import android.view.motionevent;
import android.view.velocitytracker;
import android.view.view;
import android.view.viewconfiguration;
import android.view.viewgroup;
import android.widget.scroller;

/**
 * 注意：此自定义viewgroup只适用于每个子控件为match_parent的情况，其实一般情况也都是这种情况
 * 注意：此自定义viewgroup，没有考虑padding的情况，使用者不要在scrollerlayout里使用任何padding，否则你看到的不是你想要的，
 * 为了实现padding效果，你可以为scrollerlayout的外层再套一层线性布局（或其他布局），在外层布局里使用padding值
 * 此自定义viewgroup基于郭霖博客改编，想了解具体实现细节，请参照：
 * android scroller完全解析，关于scroller你所需知道的一切
 * http://blog.csdn.net/guolin_blog/article/details/48719871
 */
public class verticalviewpager extends viewgroup {
  int currentpage = 1;

  /**
   * 速度轨迹追踪器
   */
  private velocitytracker mvelocitytracker;

  /**
   * 此次计算速度你想要的最大值
   */
  private final int mmaxvelocity;

  /**
   * 第一个触点的id， 此时可能有多个触点，但至少一个
   */
  private int mpointerid;

  /**
   * 计算出的竖向滚动速率
   */
  private float velocityy;

  /**
   * 手指横向滑动的速率临界值，大于这个值时，不考虑手指滑动的距离，直接滚动到最左边或者最右边
   */
  private int criticalvelocityy = 2500;

  /**
   * 用于完成滚动操作的实例
   */
  private scroller mscroller;

  /**
   * 判定为拖动的最小移动像素数
   */
  private int mtouchslop;

  /**
   * 手机按下时的屏幕坐标
   */
  private float mydown;

  /**
   * 手机当时所处的屏幕坐标
   */
  private float mymove;

  /**
   * 上次触发action_move事件时的屏幕坐标
   */
  private float mylastmove;

  /**
   * 界面可滚动的顶部边界
   */
  private int topborder;

  /**
   * 界面可滚动的底部边界
   */
  private int bottomborder;


  /**
   * 子控件的高度（这里每个子控件高度都一样，都是match_parent）
   */
  private int childheight;


  /**
   * 手指是否是向下滑动
   */
  private boolean shouzhixiangxiahuadong;
  private int childcount;


  public verticalviewpager(context context, attributeset attrs) {
    super(context, attrs);
    // 第一步，创建scroller的实例
    mscroller = new scroller(context);
    viewconfiguration configuration = viewconfiguration.get(context);
    // 获取touchslop值
    mtouchslop = viewconfigurationcompat.getscaledpagingtouchslop(configuration);
    //此次计算速度你想要的最大值
    mmaxvelocity = viewconfiguration.get(context).getmaximumflingvelocity();
  }

  @override
  protected void onmeasure(int widthmeasurespec, int heightmeasurespec) {
    super.onmeasure(widthmeasurespec, heightmeasurespec);
    childcount = getchildcount();
    for (int i = 0; i < childcount; i++) {
      view childview = getchildat(i);
      // 为scrollerlayout中的每一个子控件测量大小
      measurechild(childview, widthmeasurespec, heightmeasurespec);
    }
  }

  @override
  protected void onlayout(boolean changed, int l, int t, int r, int b) {
    if (changed) {
      /**
       * 当前子控件之前的所有子控件的总宽度
       */
      int prechildviewtotalheight = 0;
      for (int i = 0; i < childcount; i++) {
        view childview = getchildat(i);
        // 为scrollerlayout中的每一个子控件在竖直方向上进行布局
        if (i == 0) {
          childview.layout(
              0,
              0,
              childview.getmeasuredwidth(),
              childview.getmeasuredheight());

        } else {
          childview.layout(
              0,
              prechildviewtotalheight,
              childview.getmeasuredwidth(),
              prechildviewtotalheight + childview.getmeasuredheight());
        }
        prechildviewtotalheight += childview.getmeasuredheight();

      }
      // 初始化上下边界值
      topborder = getchildat(0).gettop();
      bottomborder = getchildat(getchildcount() - 1).getbottom();

      childheight = getchildat(0).getmeasuredheight();


    }
  }


  private int downx;
  private int downy;

  //    告诉此scrolllayout的父布局，什么时候该拦截触摸事件，什么时候不该拦截触摸事件
  public boolean dispatchtouchevent(motionevent ev) {
    switch (ev.getaction()) {
      case motionevent.action_down:
        //让当前scrollerlayout对应的父控件不要去拦截事件
        getparent().requestdisallowintercepttouchevent(true);
        downx = (int) ev.getx();
        downy = (int) ev.gety();
        break;
      case motionevent.action_move:
        int movex = (int) ev.getx();
        int movey = (int) ev.gety();

        //请求父控件viewpager拦截触摸事件，viewpager左右滚动时，不要触发该布局的上下滑动
        if (math.abs(movey - downy) < math.abs(movex - downx)) {
          getparent().requestdisallowintercepttouchevent(false);
        } else {
          //请求父控件viewpager不要拦截触摸事件，scrollerlayout自己可以上下滑动
          getparent().requestdisallowintercepttouchevent(true);
        }

        break;

      case motionevent.action_cancel:


        break;
      case motionevent.action_up:


        break;
    }
    return super.dispatchtouchevent(ev);
  }


  //   scrolllayout告诉自己什么时候要拦截内部子view的触摸事件，什么时候不要拦截内部子view的触摸事件
  @override
  public boolean onintercepttouchevent(motionevent ev) {
    switch (ev.getaction()) {
      case motionevent.action_down:
        //▲▲▲1.求第一个触点的id， 此时可能有多个触点，但至少一个
        mpointerid = ev.getpointerid(0);
        mydown = ev.getrawy();
        mylastmove = mydown;
        break;
      case motionevent.action_move:
        mymove = ev.getrawy();
        float diff = math.abs(mymove - mydown);
        mylastmove = mymove;
        // 当手指拖动值大于touchslop值时，认为应该进行滚动，拦截子控件的事件
        if (diff > mtouchslop) {
          return true;
        }
        break;
    }
    return super.onintercepttouchevent(ev);
  }


  @override
  public boolean ontouchevent(motionevent event) {
    //▲▲▲2.向velocitytracker添加motionevent
    acquirevelocitytracker(event);
    switch (event.getaction()) {
      case motionevent.action_move:

        //▲▲▲3.求伪瞬时速度
        mvelocitytracker.computecurrentvelocity(1000, mmaxvelocity);
        velocityy = mvelocitytracker.getyvelocity(mpointerid);

        mymove = event.getrawy();
        int scrolledy = (int) (mylastmove - mymove);//注意取的是负值，因为是整个布局在动，而不是控件在动


        if (getscrolly() + scrolledy < topborder) {// 如果已经在最上端了，就不让再往上滑动了(重点一、边界判断，直接照着这个模板抄就行)
          scrollto(0, topborder);
          return true;//★★★★★★★★★★★★★★★★这里返回true或者false实践证明都可以，但是不能什么都不返回。
        } else if (getscrolly() + getheight() + scrolledy > bottomborder) {//如果已经在最底部了，就不让再往底部滑动了
          scrollto(0, bottomborder - getheight());
          return true;//★★★★★★★★★★★★★★★★★这里返回true或者false实践证明都可以，但是不能什么都不返回。
        }

        scrollby(0, scrolledy);//手指move时，布局跟着滚动
        if (mydown <= mymove) {//★★★判断手指向上滑动，还是向下滑动，要用mydown，而不是mylastmove
          shouzhixiangxiahuadong = true;//手指往下滑动
        } else {
          shouzhixiangxiahuadong = false;//手指往上滑动
        }
        mylastmove = mymove;
        break;
      case motionevent.action_up:
//        4.▲▲▲释放velocitytracker
        releasevelocitytracker();

        // 第二步，当手指抬起时，根据当前的滚动值以及滚动方向来判定应该滚动到哪个子控件的界面，并且记得调用invalidate();
        if (math.abs(velocityy) > criticalvelocityy) {//当手指滑动速度快时，按照速度方向直接翻页
//          重点二、快速滑动时，如何判断当前显示的是第几个控件，并且再次包含边界判断（必须包含边界判断，因为前面的边界判断，只适用于低速滑动时）
          if (shouzhixiangxiahuadong) {
            if (currentpage > 1) {//★★★★★★★★边界限制，防止滑倒第一个，还继续滑动，注意★（currentpage-2）
              mscroller.startscroll(0, getscrolly(), 0, childheight * (currentpage - 2) - getscrolly());
              currentpage--;
            }
          } else {
            if (currentpage < childcount) {//★★★★★★★边界限制，防止滑倒最后一个，还继续滑动，注意★currentpage
              mscroller.startscroll(0, getscrolly(), 0, childheight * currentpage - getscrolly());
              currentpage++;
            }
          }
          log.e("eee", currentpage + "");
        } else {//当手指滑动速度不够快时，按照松手时，已经滑动的位置来决定翻页

//       重点三、低速滑动时，如何根据位置来判断当前显示的是第几个控件，（这里不必再次进行边界判断，因为第一次的边界判断，在这里会起到作用）
          if ((getscrolly() >= childheight * (currentpage - 1) + childheight / 2 && !shouzhixiangxiahuadong)) {
//           手指向上滑动并且，滚动距离过了屏幕一半的距离
            mscroller.startscroll(0, getscrolly(), 0, childheight * (currentpage) - getscrolly());
            currentpage++;

          } else if ((getscrolly() < childheight * (currentpage - 1) + childheight / 2 && !shouzhixiangxiahuadong)) {
//           手指向上滑动并且，滚动距离没有过屏幕一半的距离
            mscroller.startscroll(0, getscrolly(), 0, childheight * (currentpage - 1) - getscrolly());

          } else if
              ((getscrolly() <= childheight * (currentpage - 2) + childheight / 2
                  && shouzhixiangxiahuadong)) {
//            手指向下滑动并且，滚动距离过了屏幕一半的距离
            mscroller.startscroll(0, getscrolly(), 0, childheight * (currentpage - 2) - getscrolly());
            currentpage--;
          } else if
              ((getscrolly() > childheight * (currentpage - 2) + childheight / 2
                  && shouzhixiangxiahuadong)) {
//            手指向下滑动并且，滚动距离没有过屏幕一半的距离
            mscroller.startscroll(0, getscrolly(), 0, childheight * (currentpage - 1) - getscrolly());
          }

 

 


          /* if ((getscrolly() >= childheight && !shouzhixiangxiahuadong)//手指往左滑动，并且滑动完全显示第二个控件时，viewgroup滑动到最右端
              || ((getscrolly() >= (totalchildheight - firstchildheight - lastchildheight) && shouzhixiangxiahuadong))) {//手指往右滑动，并且当滑动没有完全隐藏最后一个控件时，viewgroup滑动到最右端
//          当滚动值大于某个数字时(大于第二个控件的宽度，即完全显示第二个控件时)并且是向左滑动，让这个viewgroup滑动到整个viewgroup的最右侧，
//          因为右侧的所有控件宽度是600，而现在已经滑动的距离是getscrollx，
//          那么，还应该继续滑动的距离是600-getscrollx()，这里正值表示向右滑动
            mscroller.startscroll(0,getscrolly(), 0, (totalchildheight - firstchildheight) - getscrolly());
          } else if ((getscrolly() <= (totalchildheight - firstchildheight - lastchildheight) && shouzhixiangxiahuadong)//手指往右滑动，并且当滑动完全隐藏最后一个控件时，viewgroup滑动到最左端
              || (getscrolly() <= childheight && !shouzhixiangxiahuadong)) {//手指往左滑动，并且滑动没有完全显示第二个控件时，viewgroup滑动到最左端

//          当滚动值小于某个数字时，让这个viewgroup滑动到整个viewgroup的最左侧，
//          因为滑动到最左侧时，就是让整个viewgroup的滑动量为0，而现在已经滑动的距离是getscrollx，
//          那么，还应该继续滑动的距离是0-getscrollx()，这里负值表示向左滑动
            mscroller.startscroll(0,getscrolly(), 0, 0 - getscrolly());
          }*/
        }
//        必须调用invalidate()重绘
        invalidate();
        break;

      case motionevent.action_cancel:
//       5.▲▲▲释放velocitytracker
        releasevelocitytracker();

        break;
    }
    return super.ontouchevent(event);
  }


  @override
  public void computescroll() {
    // 第三步，重写computescroll()方法，并在其内部完成平滑滚动的逻辑
    if (mscroller.computescrolloffset()) {
      scrollto(mscroller.getcurrx(), mscroller.getcurry());
      invalidate();
    }
  }

  /**
   * @param event 向velocitytracker添加motionevent
   * @see velocitytracker#obtain()
   * @see velocitytracker#addmovement(motionevent)
   */
  private void acquirevelocitytracker(final motionevent event) {
    if (null == mvelocitytracker) {
      mvelocitytracker = velocitytracker.obtain();
    }
    mvelocitytracker.addmovement(event);
  }

  /**
   * 释放velocitytracker
   *
   * @see velocitytracker#clear()
   * @see velocitytracker#recycle()
   */
  private void releasevelocitytracker() {
    if (null != mvelocitytracker) {
      mvelocitytracker.clear();
      mvelocitytracker.recycle();
      mvelocitytracker = null;
    }
  }


   /*  getscrollx()指的是由viewgroup调用view的scrollto(int x, int y)或者scrollby(int x, int y)产生的x轴的距离
//        换句话说，就是你手指每次滑动，引起的是viewgroup累计滑动的距离，右为正
//        指的是相当于控件的左上角的为原点的坐标值
        log.e("qqq","getx():"+event.getx());
//        指的是相当于屏幕的左上角的为原点的坐标值
        log.e("qqq","getrawx():"+event.getrawx());*/
}

布局文件

 <beautlful.time.com.beautlfultime.view.verticalviewpager
      android:id="@+id/verticalviewpager"
      android:layout_width="match_parent"
      android:layout_height="150dp">
      <button
        android:layout_width="match_parent"
        android:layout_height="match_parent"
      android:background="@android:color/holo_orange_dark"
        android:text="聊天具体的信息哟" />

      <button
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:background="@color/coloraccent"
        android:text="置顶" />

      <button
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:background="@color/colorprimary"
        android:text="删除" />
      <button
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:background="@color/coloraccent"
        android:text="美好" />

 

    </beautlful.time.com.beautlfultime.view.verticalviewpager>

 感谢阅读，希望能帮助到大家，谢谢大家对本站的支持！