Android自定义ViewGroup

最新推荐文章于 2024-04-27 19:18:41 发布
最新推荐文章于 2024-04-27 19:18:41 发布
阅读量453 收藏
点赞数
分类专栏： Android之旅 文章标签： android ViewGroup 滑动 自定义控件
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Lennie_Z/article/details/75007736
版权

Android自定义ViewGroup

以Dome为例，来一步一步的讲解如何自定义ViewGoup，先看下面Demo,此Demo模仿ViewPage的滑动。

这里写图片描述

从demo中可以看出，红、蓝、黄分别装载在ViewGroup中，随着手势的滑动来显示相应的View。那么ViewGroup是什么呢？

这里写图片描述

从上图我们大概可以猜到ViewGroup是什么了，此刻我在想你们是否跟我想的一样，好我们来去看看官方的解释，看是否跟大家猜的一样：

“A ViewGroup is a special view that can contain other views (called children.) The view group is the base class for layouts and views containers. ”

翻译过来大概意思是：ViewGroup是一种特殊的视图可以包含其他视图（称为孩子）的视图组基类的布局和视图的容器。

那ViewGroup怎么实现呢?这个简单，按官方文档上面的例子，实践并总结出除了构造方法之外onMeasure()、onLayout(),这两方法是必须实现的，不然你的View就无法显示在屏幕上面。看以下示例：

 import android.content.Context;
 import android.util.AttributeSet;
 import android.util.DisplayMetrics;
 import android.view.MotionEvent;
 import android.view.VelocityTracker;
 import android.view.View;
 import android.view.ViewConfiguration;
 import android.view.ViewGroup;
 import android.view.WindowManager;
 import android.widget.LinearLayout;


/**
    * Created by win7 on 2017/7/4.
    */

public class BaseViewGroup extends ViewGroup {

private final String TAG = "BaseViewGroup";

private AView centerView;
private BView rigthView;
private CView leftView;
private VelocityTracker mVelocityTracker; //速率捕捉器

private final int SCREEN_LEFT = 1;  // 左屏
private final int SCREEN_CENTER = 2; //中屏
private final int SCREEN_RIGHT = 3;//右屏
private final int mUnits = 1000;//手势滑动速度
private final int mDuration = -1;
private int mTouchSlop; //滑动阀值
private int mMaximumVelocity; //最大移动速度
private int mActivePointerId;//活动触摸点
private int mCurrentScreen = 2; //当前所处屏
private int mScreenWidth; //屏幕宽度
private float mLastMotionX; //上一次移动点的位置

private boolean mPointInViews; //触摸点是否在指定范围内
private boolean mScrolled; //是否滑动

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

 public BaseViewGroup(Context context, AttributeSet attrs) {
    this(context, attrs, -1);
 }

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

 private void init(Context context) {
    //获取屏幕宽度
    DisplayMetrics displayMetrics = new DisplayMetrics();
    WindowManager windowManager = (WindowManager) context
            .getSystemService(Context.WINDOW_SERVICE);
    windowManager.getDefaultDisplay().getMetrics(displayMetrics);
    mScreenWidth = displayMetrics.widthPixels;


    LinearLayout.LayoutParams aLayoutParams = new LinearLayout.LayoutParams(
            LinearLayout.LayoutParams.MATCH_PARENT,
            LinearLayout.LayoutParams.WRAP_CONTENT);
    LinearLayout.LayoutParams layoutParams = new LinearLayout.LayoutParams(
            LinearLayout.LayoutParams.MATCH_PARENT,
            LinearLayout.LayoutParams.MATCH_PARENT);

    //中屏
    centerView = new AView(context);
    this.addView(centerView, aLayoutParams);
    //右屏
    rigthView = new BView(context);
    this.addView(rigthView, layoutParams);
    //左屏
    leftView = new CView(context);
    this.addView(leftView, layoutParams);
    //获取标准的常量用来设置UI的超时、大小和距离
    ViewConfiguration configuration = ViewConfiguration.get(context);
    //获取用户认为滚动之前，触摸可以移动像素的距离。
    mTouchSlop = configuration.getScaledTouchSlop();
    //获取滑动的最大速度, 以像素/每秒来进行计算
    mMaximumVelocity = configuration.getScaledMaximumFlingVelocity();

}


/**
 *要求所有子View测量自己并计算这一点的测量值
 *基于View的布局.
 */
 @Override
 protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
    super.onMeasure(widthMeasureSpec, heightMeasureSpec);
    //测量原始的大小
    int defaultWidth = getDefaultSize(getSuggestedMinimumWidth(), widthMeasureSpec);
    int defaultHeight = getDefaultSize(getSuggestedMinimumHeight(), heightMeasureSpec);
    //测量子View的大小
    final int count = getChildCount();
    for (int i = 0; i < count; i++) {
        View child = getChildAt(i);
        measureChildWithMargins(child, widthMeasureSpec, 0, heightMeasureSpec, 0);
    }

    //保存测量结果
    setMeasuredDimension(defaultWidth, defaultHeight);
}

/**
 *在布局中放置所有的子节点
 */ 
@Override
protected void onLayout(boolean changed, int l, int t, int r, int b) {
    int width = this.getWidth();
    int height = this.getHeight();
    //对子View进行排版
    centerView.layout(0, 0, width, height);
    rigthView.layout(0, 0, width, height);
    leftView.layout(0, 0, width, height);
    //改变left和right的坐标点位置，以达到左、中、右三屏效果
    rigthView.scrollTo(-width, 0);
    leftView.scrollTo(width, 0);

 }

@Override
public boolean dispatchTouchEvent(MotionEvent ev) {
    return super.dispatchTouchEvent(ev);
}

/**
 *判断触摸点是否在子View上
 *@param ev
 *@return
 */
public boolean pointInViews(MotionEvent ev) {
    boolean rigthView = false;
    float x = ev.getX();
    float y = ev.getY();
    if (mCurrentScreen == SCREEN_CENTER) {
        return centerView.pointInViews(x, y);
    } else if (mCurrentScreen == SCREEN_LEFT) {
        return leftView.pointInViews(x, y);
    } else if (mCurrentScreen == SCREEN_RIGHT) {
        return this.rigthView.pointInViews(x, y);
    }
    return rigthView;
}

/**事件拦截*/
@Override
public boolean onInterceptTouchEvent(MotionEvent ev) {
    mPointInViews = pointInViews(ev);
    if (!mPointInViews) {
        return false;
    }
    final float x = ev.getX();
    final float y = ev.getY();
    // 防止事件冲突
    getParent().requestDisallowInterceptTouchEvent(true);
    boolean handle = super.onInterceptTouchEvent(ev);
    switch (ev.getAction()) {
        case MotionEvent.ACTION_DOWN:
            mLastMotionX = x;
            //获取手势触控点
            if (ev.getPointerCount() > 0) {
                mActivePointerId = ev.getPointerId(0);
            }
            break;
        case MotionEvent.ACTION_MOVE:
            //根据手势滑动距离来判断是否拦截此次手势事件
            if (Math.abs(x - mLastMotionX) >= mTouchSlop) {
                handle = true;
            }
            break;
        case MotionEvent.ACTION_UP:
            break;
    }

    return handle;
}


@Override
public boolean onTouchEvent(MotionEvent event) {

    if (!mPointInViews) {
        return false;
    }

    if (null == mVelocityTracker) {
        //初始化速率捕捉器
        mVelocityTracker = VelocityTracker.obtain();
    }
    if (null != mVelocityTracker) {
        //删除手势
        mVelocityTracker.addMovement(event);
    }

    switch (event.getAction() & MotionEvent.ACTION_MASK) {
        case MotionEvent.ACTION_DOWN:
            //记录手势按下的X坐标点
            mLastMotionX = event.getX();
            mScrolled = false;
            break;
        case MotionEvent.ACTION_MOVE:
            //是否有手势触控点
            final int activePointerIndex = event.getPointerCount() > mActivePointerId ? event.findPointerIndex(mActivePointerId) : -1;
            if (activePointerIndex == -1) {
                break;
            }
            //获取手势触控点的X坐标
            int x = (int) event.getX(activePointerIndex);
            //计算滑动过程
            int move = (int) mLastMotionX - x;
            if (mScrolled) {
                mLastMotionX = x;
                onTouchMove(move);
            } else if (Math.abs(x - mLastMotionX) >= mTouchSlop) {
                mScrolled = true;
                onTouchMove(move);
            }

            break;
        case MotionEvent.ACTION_POINTER_UP:
        case MotionEvent.ACTION_UP:
            if (mActivePointerId < 0) {
                break;
            }
            final int activeUpPointerIndex = event.getPointerCount() > mActivePointerId ? event.findPointerIndex(mActivePointerId) : -1;
            if (activeUpPointerIndex == -1) {
                break;
            }

            if (event.getPointerId(event.getActionIndex()) != mActivePointerId) {
                break;
            }
            //计算当前手势的速度
            mVelocityTracker.computeCurrentVelocity(mUnits, mMaximumVelocity);
            //获取当前手势X移动的速度
            float mVelocityX = mVelocityTracker.getXVelocity();
            mActivePointerId = -1;
            scrollToNextScreen(mVelocityX);
            break;
        case MotionEvent.ACTION_POINTER_DOWN:
            break;
        case MotionEvent.ACTION_CANCEL:
            releaseTracker();

    }

    return true;
}

/**
 *释放速率捕捉器
 */
private void releaseTracker() {
    if (mVelocityTracker != null) {
        mVelocityTracker.recycle();
        mVelocityTracker = null;
    }
}


/**
 *根据X坐标位移
 */
private void onTouchMove(int move) {
    if (mCurrentScreen == SCREEN_LEFT) {
        leftView.scrollBy(move, 0);
        centerView.scrollBy(move, 0);
    } else if (mCurrentScreen == SCREEN_CENTER) {
        centerView.scrollBy(move, 0);
        leftView.scrollBy(move, 0);
        rigthView.scrollBy(move, 0);
    } else if (mCurrentScreen == SCREEN_RIGHT) {
        rigthView.scrollBy(move, 0);
        centerView.scrollBy(move, 0);
    }
}


/**
 *根据手势的速度来判断滑动的方向
 *@param mVelocityX 当前手势X移动的速度
 */
private void scrollToNextScreen(float mVelocityX) {
    boolean isScrollToNextScreen = false;
    if (mVelocityX > mUnits) {
        isScrollToNextScreen = false;
    } else if (mVelocityX < -mUnits) {
        isScrollToNextScreen = true;
    } else {
        if (leftView.isHalfDisplaying()) {
            // left
            snapTo(SCREEN_LEFT, mScreenWidth);
        } else if (rigthView.isHalfDisplaying()) {
            // right
            snapTo(SCREEN_RIGHT, mScreenWidth);
        } else {
            snapTo(SCREEN_CENTER, mScreenWidth);
        }

        return;
    }
    int nextScreen;
    if (leftView.isScrolling() || leftView.isAllDisplaying()) {
        nextScreen = SCREEN_LEFT;
    } else if (rigthView.isAllDisplaying()) {
        nextScreen = SCREEN_RIGHT;
    } else {
        nextScreen = SCREEN_CENTER;
    }

    if (isScrollToNextScreen) {
        nextScreen++;
    } else {
        if (nextScreen != SCREEN_LEFT && mCurrentScreen != SCREEN_RIGHT) {
            nextScreen--;
        }
    }

    if (nextScreen > SCREEN_RIGHT) {
        snapTo(nextScreen, mScreenWidth);
    } else if (nextScreen == SCREEN_RIGHT) {
        snapTo(nextScreen, mScreenWidth);
    } else if (nextScreen <= SCREEN_RIGHT && nextScreen >= SCREEN_LEFT) {
        snapTo(nextScreen, mScreenWidth);
    }
}

 /**
  *滑动到某一屏
  *@param toCurrent
  *@param x
  */
private void snapTo(int toCurrent, int x) {

    if (SCREEN_LEFT == toCurrent) {

        leftView.snapTo(0, mDuration);
        centerView.snapTo(-x, mDuration);
        rigthView.snapTo(-x, 0);
        mCurrentScreen = 1;

    } else if (SCREEN_CENTER == toCurrent) {

        centerView.snapTo(0, mDuration);
        rigthView.snapTo(-x, mDuration);
        leftView.snapTo(x, mDuration);
        mCurrentScreen = SCREEN_CENTER;

    } else if (SCREEN_RIGHT == toCurrent) {

        rigthView.snapTo(0, mDuration);
        centerView.snapTo(x, mDuration);
        leftView.snapTo(x, mDuration);
        mCurrentScreen = SCREEN_RIGHT;

    }
}

}

onMeasure()、onLayout()这个两个重要的函数，我会在后面的ViewGroup、View之onMeasure、onLayout解刨中详细讲解。
onInterceptTouchEvent 我会在后面的View和ViewGroup事件分发机制中讲解

到此，对Viewgroup的讲解就暂告一段落，建议大家动手实践，附上Dmoe源码

Lennie_z
关注
专栏目录
Android中自定义ViewGroup，Android开发岗还不会这些问题
m0_64603743的博客
12-08 136
2、ViewGroup是一个基类，并且是Layout和一些View组件的基类。 等等，不一而足，眼界有多高相信看到的就有多远，呵呵。 二、ViewGroup的三个方法 在继承ViewGroup时有三个重要的方法，下面我们就来看看： 1、onLayout方法 protected  void onLayout( boolean changed,  int left,  int top,  int right, 
Android 自定义ViewGroup
maozhuxigood
04-09 167
版本：1.0 日期：2014.4.2 版权：© 2014 kince 转载注明出处 之前介绍了关于自定义View类的一些知识，总结一下就是继承于View类，重写onDraw()方法。如果组件有自己的属性的话，在attrs.xml文件中加入即可。这类View一般只是用于显示一个位图或者一段文本，像TextView。实际开发中，用的不是很多，真正需求多的是像SliddingMenu侧滑菜单、...
Android 手把手教您自定义ViewGroup（一）
810364804
08-02 1483
转载请标明出处：http://blog.csdn.net/lmj623565791/article/details/38339817， 本文出自:【张鸿洋的博客】 最近由于工作的变动，导致的博客的更新计划有点被打乱，希望可以尽快脉动回来~ 今天给大家带来一篇自定义ViewGroup的教程，说白了，就是教大家如何自定义ViewGroup，如果你对自定义ViewGroup还不是很了解，或者正想学习如何...
Android中自定义ViewGroup
小冰的程序员之旅
08-21 1229
一、ViewGroup概述 研究ViewGroup之前，我们先来看看ViewGroup的介绍： /** *AViewGroupisaspecialviewthatcancontainotherviews *(calledchildren.)Theviewgroupisthebas...
Android自定义ViewGroup实现标签浮动效果
01-06
前面在学习鸿洋大神的一些自定义的View文章，看到了自定义ViewGroup实现浮动标签，初步看了下他的思路以及结合自己的思路完成了自己的浮动标签的自定义ViewGroup。目前实现的可以动态添加标签、可点击。效果图如下：...
Android自定义viewGroup实现点击动画效果
01-20
在Android开发中，自定义ViewGroup是创建复杂用户界面或实现独特交互效果的重要手段。本文将探讨如何在自定义的ViewGroup中实现点击动画效果，具体以`MyCustomView`为例，它继承自ViewGroup并实现了`OnClickListener...
Android自定义ViewGroup实现标签流容器FlowLayout
09-01
在Android开发中，自定义ViewGroup是实现特定布局需求的重要手段。本文主要讲解如何自定义一个名为FlowLayout的标签流容器，适用于展示类似热门标签的自动换行布局。Flow Layout是一种布局方式，它允许子视图根据...
Android自定义viewgroup 使用adapter适配数据（6）
08-31
在Android开发中，自定义ViewGroup是实现特定布局或交互效果的重要手段。在这个场景中，我们看到一个自定义的ViewGroup子类`ScrollViewGroup`，它扩展...这个案例对于学习Android自定义视图和数据适配机制非常有帮助。
Android---自定义ViewGroup
本人随手记录，内容只是个人看懂程度，对内容有任何疑问请勿打扰
10-14 320
效果图： ViewGroup子类： 创建过程： 1，构造方法 2，添加子View方法 3，测量（onMeasure）,确认父类size 4，调整子View的布局（onLayout） /** * 创建过程： * 1，构造方法 * 2，添加子View方法 * 3，测量（onMeasure）,确认父类size * 4，调整子View的布局（onLayout） */ public class VGTest extends ViewGroup { //存放传过来的子View数据
Android面试题-手把手教你如何解决as jar包冲突
最新发布
2401_84538135的博客
04-27 605
今天关于面试的分享就到这里，还是那句话，有些东西你不仅要懂，而且要能够很好地表达出来，能够让面试官认可你的理解，例如Handler机制，这个是面试必问之题。有些晦涩的点，或许它只活在面试当中，实际工作当中你压根不会用到它，但是你要知道它是什么东西。最后在这里小编分享一份自己收录整理上述技术体系图相关的几十套腾讯、头条、阿里、美团等公司19年的面试题，把技术点整理成了视频和PDF（实际上比预期多花了不少精力），包含知识脉络 + 诸多细节，由于篇幅有限，这里以图片的形式给大家展示一部分。还有。
【Android】Android自定义ViewGroup
minkee的博客
02-27 515
ViewGroup存在的目的就是对其子View进行管理，为其子View添加显示、响应的规则。因此，自定义ViewGroup通常需要重写onMeasure()方法对其子View进行测量，重写onLayout()方法来确定子View的位置，重写onTouchEvent()方法增加响应事件。所以我们需要做这几件事： 重写onMeasure()方法对其子View进行测量 重写onLayout()方法来确定子
Android之自定义ViewGroup
Caben_的博客
09-11 626
今天看了鸿洋大神的自定义viewgroup，现在做一下笔记首先，创建默认构造方法，如下所示 public FlowLayout(Context context) { super(context,null); }public FlowLayout(Context context, AttributeSet attrs) { super(context, att
Android 自定义 ViewGroup
huadi223的专栏
10-10 96
占位符 占位符 public class Workspace extends ViewGroup { // 省略了构造方法 @Override protected void onLayout(boolean changed, int l, int t, int r, int b) { int childLeft = 0; final int count = getChi...
Android 自定义viewgroup
07-28
Android自定义ViewGroup是指在Android开发中，通过继承ViewGroup类来创建自定义的布局容器。自定义ViewGroup可以用于实现一些特殊的布局效果，比如侧滑菜单、滑动卡片等等。通过自定义ViewGroup，我们可以更灵活地...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值