Android 滚轮选择器的实现详解

最新推荐文章于 2024-04-24 16:33:01 发布
最新推荐文章于 2024-04-24 16:33:01 发布
阅读量628 收藏 1
点赞数
文章标签： 移动开发 面试 java
原文链接：https://juejin.im/post/5cb86fd2e51d456e60003ae2
版权

简介

最近用一个日期选择控件，感觉官方的DatePicker操作有点复杂,而且不同的Android版本样式也都不一样。后来发现小米日历的日期选择控件蛮好看的，于是自己尝试仿写一个，感觉效果还不错。

效果图：

Picture

Picture

功能分析

  • 滚轮：首先绘制一列文本，然后添加一个偏移量，在onDraw中根据手指滑动，改变偏移量并重新绘制这一列文本，这样就实现了滑动的效果。

  • Fling：这个应该很常见了，用VelocityTracker和Scroller来实现。

  • 循环滚动：当滚动超过数据集的大小后，从头继续获取数据即可。

  • 幕布效果：在中心区域绘制一个矩形。

  • 字体颜色渐变：

  • 从中心到两边，逐渐将Paint的透明度变小。

  • 从中心相邻项到中心，字体颜色渐变。

  • 中心选项文字变大： 从中心相邻项到中心，字体大小渐变。

  • 指示器文字，在中间的Item后边绘制一个文字。

到这里，所有的功能点的思路大概就清晰了。

实现方法

测量控件大小

这里主要是测量wrap_content模式的大小。 首先，要确定单个item的文字的宽高。代码如下：

public void computeTextSize() {
    mTextMaxWidth = mTextMaxHeight = 0;
    if (mDataList.size() == 0) {    
        return;
    }

    //这里使用最大的,防止文字大小超过布局大小。
    mPaint.setTextSize(mSelectedItemTextSize > mTextSize ? mSelectedItemTextSize : mTextSize);

    if (!TextUtils.isEmpty(mItemMaximumWidthText)) {
        mTextMaxWidth = (int) mPaint.measureText(mItemMaximumWidthText);
    } else {
        mTextMaxWidth = (int) mPaint.measureText(mDataList.get(0).toString());
    }
    Paint.FontMetrics metrics = mPaint.getFontMetrics();
    mTextMaxHeight = (int) (metrics.bottom - metrics.top);
}
然后确定布局的大小，布局的宽度就等于测量的mTextMaxWidth，高度为测量的mTextMaxHeight * itemCount。这里宽高中可以加入一个额外的Space，要不然文字就会挤到一起，比较难看。

    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        int specWidthSize = MeasureSpec.getSize(widthMeasureSpec);
        int specWidthMode = MeasureSpec.getMode(widthMeasureSpec);
        int specHeightSize = MeasureSpec.getSize(heightMeasureSpec);
        int specHeightMode = MeasureSpec.getMode(heightMeasureSpec);
    
        int width = mTextMaxWidth + mItemWidthSpace;
        int height = (mTextMaxHeight + mItemHeightSpace) * getVisibleItemCount();
    
        width += getPaddingLeft() + getPaddingRight();
        height += getPaddingTop() + getPaddingBottom();
        setMeasuredDimension(measureSize(specWidthMode, specWidthSize, width),
                measureSize(specHeightMode, specHeightSize, height));
    }
    
    private int measureSize(int specMode, int specSize, int size) {
        if (specMode == MeasureSpec.EXACTLY) {
            return specSize;
        } else {
            return Math.min(specSize, size);
        }
    }
复制代码

然后确定布局的大小，布局的宽度就等于测量的mTextMaxWidth，高度为测量的mTextMaxHeight * itemCount。这里宽高中可以加入一个额外的空间，要不然文字就会挤到一起，比较难看。

    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        int specWidthSize = MeasureSpec.getSize(widthMeasureSpec);
        int specWidthMode = MeasureSpec.getMode(widthMeasureSpec);
        int specHeightSize = MeasureSpec.getSize(heightMeasureSpec);
        int specHeightMode = MeasureSpec.getMode(heightMeasureSpec);
    
        int width = mTextMaxWidth + mItemWidthSpace;
        int height = (mTextMaxHeight + mItemHeightSpace) * getVisibleItemCount();
    
        width += getPaddingLeft() + getPaddingRight();
        height += getPaddingTop() + getPaddingBottom();
        setMeasuredDimension(measureSize(specWidthMode, specWidthSize, width),
                measureSize(specHeightMode, specHeightSize, height));
    }
    
    private int measureSize(int specMode, int specSize, int size) {
        if (specMode == MeasureSpec.EXACTLY) {
            return specSize;
        } else {
            return Math.min(specSize, size);
        }
    }
复制代码

###滚轮的绘制 一般滚轮被选中的位置都是在中间，所以显示的设置为奇数比较合适。为了方便，定义mHalfVisibleItemCount作为显示的个数的一半，总显示个数为mHalfVisibleItemCount * 2 + 1，这样就可以保证选中的item在正中间。

首先最简单的，不考虑滚动的情况，直接绘制一列文字，这里为了方便计算，设置中间的为数据集的第0个，第一个item就为0-mHalfVisibleItemCount，最后一个则为mHalfVisibleItemCount，代码如下：

protected void onDraw(Canvas canvas) {
    for (int drawDataPos = -mHalfVisibleItemCount; drawDataPos <= mHalfVisibleItemCount; drawDataPos++) {
        if (pos < 0 || pos > mDataList.size() - 1) {
            continue;
        }
        int itemDrawY = mFirstItemDrawY + (drawDataPos + mHalfVisibleItemCount) * mItemHeight;
        T data = mDataList.get(pos);
        canvas.drawText(data.toString(), mFirstItemDrawX, itemDrawY, mPaint);
    }
}
复制代码

接下来加入滚动，获取手指滑动的值，然后绘制的时候添加偏移量就好了。

手指滑动，这个应该都懂，这里就不废话了，直接上代码：

public boolean onTouchEvent(MotionEvent event) {
    switch (event.getAction()) {
        case MotionEvent.ACTION_DOWN:
            mLastDownY = (int) event.getY();
            break;
        case MotionEvent.ACTION_MOVE:
            float move = event.getY() - mLastDownY;
            mScrollOffsetY += move;     //滑动的偏移量
            mLastDownY = (int) event.getY();
            invalidate();
            break;
        case MotionEvent.ACTION_UP:
            break;
    }
复制代码

更改onDraw()的代码这边有两个问题：

  • 上下两边要多绘制一个出来，因为在滚动的时候，实际在容器内的物品要比原定的项目要多一个。

  • 定位中间向位于数据集的位置，用偏移量/ item的高度即可。由于手指的坐标是以左上角为原点的，这里要注意坐标正负问题。 代码如下：

protected void onDraw(Canvas canvas) {
    int drawnSelectedPos = - mScrollOffsetY / mItemHeight;
    for (int drawDataPos = drawnSelectedPos - mHalfVisibleItemCount - 1;drawDataPos <= drawnSelectedPos + mHalfVisibleItemCount + 1; drawDataPos++) {
        if (drawDataPos < 0 || drawDataPos > mDataList.size() - 1) {
            continue;
        }
        int itemDrawY = mFirstItemDrawY + (drawDataPos + mHalfVisibleItemCount) * mItemHeight + mScrollOffsetY;
        T data = mDataList.get(drawDataPos);
        canvas.drawText(data.toString(), mFirstItemDrawX, itemDrawY, mPaint);
    }
}
复制代码

###弗林的效果 先上主要代码：

public boolean onTouchEvent(MotionEvent event) {
    if (mTracker == null) {
        mTracker = VelocityTracker.obtain();
    }
    mTracker.addMovement(event);
    switch (event.getAction()) {
        case MotionEvent.ACTION_DOWN:
            mTracker.clear();
            mTouchDownY = mLastDownY = (int) event.getY();
            break;
        case MotionEvent.ACTION_MOVE:
            mTouchSlopFlag = false;
            float move = event.getY() - mLastDownY;
            mScrollOffsetY += move;
            mLastDownY = (int) event.getY();
            invalidate();
            break;
        case MotionEvent.ACTION_UP:
            mTracker.computeCurrentVelocity(1000, mMaximumVelocity);
            int velocity = (int) mTracker.getYVelocity();
            mScroller.fling(0, mScrollOffsetY, 0, velocity,
                    0, 0, mMinFlingY, mMaxFlingY);
            mScroller.setFinalY(mScroller.getFinalY() +
                    computeDistanceToEndPoint(mScroller.getFinalY() % mItemHeight));
            mHandler.post(mScrollerRunnable);
            mTracker.recycle();
            mTracker = null;
            break;
    }
    return true;
}

private int computeDistanceToEndPoint(int remainder) {
    if (Math.abs(remainder) > mItemHeight / 2) {
        if (mScrollOffsetY < 0) {
            return -mItemHeight - remainder;
        } else {
            return mItemHeight - remainder;
        }
    } else {
        return -remainder;
    }
}

private Runnable mScrollerRunnable = new Runnable() {
    @Override
    public void run() {
        if (mScroller.computeScrollOffset()) {
            int scrollerCurrY = mScroller.getCurrY();
            mScrollOffsetY = scrollerCurrY;
            postInvalidate();
            mHandler.postDelayed(this, 16);
        }
    }
}
复制代码

弗林的效果主要实现的英文用的VelocityTracker状语从句：Scroller，网上已经有很多资料了，这里就不再说明了。这里主要就是获取滚轮当前滚动的值，加入然后到偏移量mScrollOffsetY后请求重新绘制。

这里有一个finalY的修正计算当动画停止的时候，停止的位置如果随缘的话，就会经常在停在这种位置：

图片

因为要保证当滑动停止的时候，要保证项目正好在中间也就是这样：

图片

修正的方法就是：。滚动的值只能为项目高度的整数这样就能保证，滚动结束中间的项目只能在正中间利用这个原理，上边的手指滑动，也能在手指离开屏幕后来修正位置。

这里还要考虑一个问题，滚动的时候可能会超过给定的数据集的大小，就是当滚动的值超过最后一个数据后，当手指松开后返回到最后一个数据的位置，即下图的效果：

图片

方法还是在ACTION_UP的时候判断是否超过数据集的大小即可代码如下：

protected void onSizeChanged(int w, int h, int oldw, int oldh) {
    ...
    mMinFlingY = - mItemHeight * (mDataList.size() - 1);
    mMaxFlingY = 0;
}


@Override
public boolean onTouchEvent(MotionEvent event) {
    ...
    
    case MotionEvent.ACTION_UP:
        mTracker.computeCurrentVelocity(1000, mMaximumVelocity);
        int velocity = (int) mTracker.getYVelocity();
        mScroller.fling(0, mScrollOffsetY, 0, velocity,
                0, 0, mMinFlingY, mMaxFlingY);
        mScroller.setFinalY(mScroller.getFinalY() +
                computeDistanceToEndPoint(mScroller.getFinalY() % mItemHeight));
                
        if (mScroller.getFinalY() > mMaxFlingY) {
            mScroller.setFinalY(mMaxFlingY);
        } else if (mScroller.getFinalY() < mMinFlingY) {
            mScroller.setFinalY(mMinFlingY);
        }
    
    ...
}
复制代码

###循环滚动 接下来要考虑循环滚动的问题。

首先上边的mMinFlingY和mMaxFlingY在循环滚动的时候就要设置成Integer的极限值，如下

mMinFlingY = mIsCyclic ? Integer.MIN_VALUE : - mItemHeight * (mDataList.size() - 1);
mMaxFlingY = mIsCyclic ? Integer.MAX_VALUE : 0;
复制代码

然后考虑绘制的时候取值问题，在上边的onDraw（）方法的里面有一个安全值判断，如果超过数据集的大小就跳过此条项绘制，代码如下：

protected void onDraw(Canvas canvas) {
    int drawnSelectedPos = - mScrollOffsetY / mItemHeight;
    for (int drawDataPos = drawnSelectedPos - mHalfVisibleItemCount - 1;drawDataPos <= drawnSelectedPos + mHalfVisibleItemCount + 1; drawDataPos++) {
        if (drawDataPos < 0 || drawDataPos > mDataList.size() - 1) {
            continue;
        }
        ...
    }
}
复制代码

我们要改动的就是这里。当循环滚动的时候上下滚动的极限都为无穷，所以- mScrollOffsetY / mItemHeight;得到的值应该也在正负无穷之间，我们要把值都映射到数据集中。 假设数据集有10条数据，当前滚动的位置为POS：

当pos> 10时，假设当pos = 10时，我们想让其回到第一个数据，对其取余即可：pos % 10。

当pos <0时，假设当pos = -1时，应该要展示最后一个数据，对其数据增加正数的修正为：10 + (pos % 10) 所以上边的代码就可以改变成：

protected void onDraw(Canvas canvas) {
    int drawnSelectedPos = - mScrollOffsetY / mItemHeight;
    for (int drawDataPos = drawnSelectedPos - mHalfVisibleItemCount - 1;drawDataPos <= drawnSelectedPos + mHalfVisibleItemCount + 1; drawDataPos++) {
        int pos = drawDataPos;
        if  (mIsCyclic) {
            if (pos < 0) {
                pos = mDataList.size() + (pos % mDataList.size());
            }
            if (pos >= mDataList.size()){
                pos = pos % mDataList.size();
            }
        } else {
            if (drawDataPos < 0 || drawDataPos > mDataList.size() - 1) {
                continue;
            }
        }
        ...
    }
}
复制代码

###幕布 这个就比较简单了，在中间画一个矩形就好了，不过要在绘制滚轮之前绘制，否则会遮盖住文字，代码如下：

protected void onSizeChanged(int w, int h, int oldw, int oldh) {
    ...
    mDrawnRect.set(getPaddingLeft(), getPaddingTop(),
        getWidth() - getPaddingRight(), getHeight() - getPaddingBottom());
    mSelectedItemRect.set(getPaddingLeft(), mItemHeight * mHalfVisibleItemCount,getWidth() - getPaddingRight(), mItemHeight + mItemHeight * mHalfVisibleItemCount);
}
@Override
protected void onDraw(Canvas canvas) {
    super.onDraw(canvas);
    mPaint.setTextAlign(Paint.Align.CENTER);
    //是否绘制幕布
    if (mIsShowCurtain) {
        mPaint.setStyle(Paint.Style.FILL);
        mPaint.setColor(mCurtainColor);
        canvas.drawRect(mSelectedItemRect, mPaint);
    }
    //是否绘制幕布边框
    if (mIsShowCurtainBorder) {
        mPaint.setStyle(Paint.Style.STROKE);
        mPaint.setColor(mCurtainBorderColor);
        canvas.drawRect(mSelectedItemRect, mPaint);
        canvas.drawRect(mDrawnRect, mPaint);
    }
    ...
}
复制代码

字体颜色渐变

这个分三个部分：

1.透明度渐变：

涂料在绘制文字的时候可以设置阿尔法来设置透明度，阿尔法的比例计算方法：

frac {绘制点到端点距离} {中心绘制点到端点距离}

如下图所示，计算“03”的比例：

图片

主要代码如下：

@Override
protected void onDraw(Canvas canvas) {
    ...
    int drawnSelectedPos = - mScrollOffsetY / mItemHeight;
    for (int drawDataPos = drawnSelectedPos - mHalfVisibleItemCount - 1;drawDataPos <= drawnSelectedPos + mHalfVisibleItemCount + 1; drawDataPos++) {
        int pos = drawDataPos;
        if  (mIsCyclic) {
            if (pos < 0) {
                pos = mDataList.size() + (pos % 10);
            } else {
                pos = pos % mDataList.size();
            }
        } else {
            if (drawDataPos < 0 || drawDataPos > mDataList.size() - 1) {
                continue;
            }
        }
        
        T data = mDataList.get(pos);
        int itemDrawY = mFirstItemDrawY + (drawDataPos + mHalfVisibleItemCount) * mItemHeight + mScrollOffsetY;
        //距离中心的Y轴距离
        int distanceY = Math.abs(mCenterItemDrawnY - itemDrawY);
        
        float alphaRatio;
        if (itemDrawY > mCenterItemDrawnY) {
            alphaRatio = (mDrawnRect.height() - itemDrawY) /
                    (float) (mDrawnRect.height() - (mCenterItemDrawnY));
        } else {
            alphaRatio = itemDrawY / (float) mCenterItemDrawnY;
        }
        mPaint.setAlpha((int) (alphaRatio * 255));
        canvas.drawText(data.toString(), mFirstItemDrawX, itemDrawY, mPaint);
        ...
    }
}
复制代码

###2.文字颜色渐变 当距离中心绘制点的距离小于一个ItemHeight时，进行文字颜色渐变。 首先需要一个线性颜色渐变的工具，思路就是指定一个开始颜色和结束颜色，传入比例获取颜色比较简单，直接看代码：

public class LinearGradient {

    private int mStartColor;
    private int mEndColor;
    private int mRedStart;
    private int mBlueStart;
    private int mGreenStart;
    private int mRedEnd;
    private int mBlueEnd;
    private int mGreenEnd;
    
    public LinearGradient(@ColorInt int startColor, @ColorInt int endColor) {
        mStartColor = startColor;
        mEndColor = endColor;
        updateColor();
    }
    
    
    public void setStartColor(@ColorInt int startColor) {
        mStartColor = startColor;
        updateColor();
    }
    
    public void setEndColor(@ColorInt int endColor) {
        mEndColor = endColor;
        updateColor();
    }
    
    private void updateColor() {
        mRedStart = Color.red(mStartColor);
        mBlueStart = Color.blue(mStartColor);
        mGreenStart = Color.green(mStartColor);
        mRedEnd = Color.red(mEndColor);
        mBlueEnd = Color.blue(mEndColor);
        mGreenEnd = Color.green(mEndColor);
    }
    
    public int getColor(float ratio) {
        int red = (int) (mRedStart + ((mRedEnd - mRedStart) * ratio + 0.5));
        int greed = (int) (mGreenStart + ((mGreenEnd - mGreenStart) * ratio + 0.5));
        int blue = (int) (mBlueStart + ((mBlueEnd - mBlueStart) * ratio + 0.5));
        return Color.rgb(red, greed, blue);
    }
}
复制代码

接下来就是计算文字颜色渐变了，和上边的计算透明度的类似，代码如下：

protected void onDraw(Canvas canvas) {
    ...
    int drawnSelectedPos = - mScrollOffsetY / mItemHeight;
    for (int drawDataPos = drawnSelectedPos - mHalfVisibleItemCount - 1;drawDataPos <= drawnSelectedPos + mHalfVisibleItemCount + 1; drawDataPos++) {
        ...
        
        T data = mDataList.get(pos);
        int itemDrawY = mFirstItemDrawY + (drawDataPos + mHalfVisibleItemCount) * mItemHeight + mScrollOffsetY;
        //距离中心的Y轴距离
        int distanceY = Math.abs(mCenterItemDrawnY - itemDrawY);
        
        //计算文字颜色渐变
        //文字颜色渐变要在设置透明度上边，否则透明度会被覆盖
        if (distanceY < mItemHeight) {
            float colorRatio = 1 - (distanceY / (float) mItemHeight);
            mPaint.setColor(mLinearGradient.getColor(colorRatio));
        } else {
            mPaint.setColor(mTextColor);
        }
        
        //计算透明度渐变
        float alphaRatio;
        if (itemDrawY > mCenterItemDrawnY) {
            alphaRatio = (mDrawnRect.height() - itemDrawY) /
                    (float) (mDrawnRect.height() - (mCenterItemDrawnY));
        } else {
            alphaRatio = itemDrawY / (float) mCenterItemDrawnY;
        }
        mPaint.setAlpha((int) (alphaRatio * 255));
        canvas.drawText(data.toString(), mFirstItemDrawX, itemDrawY, mPaint);
        ...
    }
}
复制代码

###3.文字大小渐变： 这个和文字颜色渐变实现思路一模一样，变化的项由文字的颜色变为大小也是在中心位置一个ItemHeigh的距离进行计算，直接上代码：

protected void onDraw(Canvas canvas) {
    ...
    int drawnSelectedPos = - mScrollOffsetY / mItemHeight;
    for (int drawDataPos = drawnSelectedPos - mHalfVisibleItemCount - 1;drawDataPos <= drawnSelectedPos + mHalfVisibleItemCount + 1; drawDataPos++) {
        ...
        //计算透明度渐变
        float alphaRatio;
        if (itemDrawY > mCenterItemDrawnY) {
            alphaRatio = (mDrawnRect.height() - itemDrawY) /
                    (float) (mDrawnRect.height() - (mCenterItemDrawnY));
        } else {
            alphaRatio = itemDrawY / (float) mCenterItemDrawnY;
        }
        mPaint.setAlpha((int) (alphaRatio * 255));
        
        //靠近中心的Item字体放大
        if (distanceY < mItemHeight) {
            float addedSize = (mItemHeight - distanceY) / (float) mItemHeight * (mSelectedItemTextSize - mTextSize);
            mPaint.setTextSize(mTextSize + addedSize);
        } else {
            mPaint.setTextSize(mTextSize);
        }
        canvas.drawText(data.toString(), mFirstItemDrawX, itemDrawY, mPaint);
        ...
    }
}
复制代码

###指示器文字实现 指示器文字就是直接在中间的项目后边绘制一个文字，只需要计算一下要绘制的坐标即可，在直接onDraw()方法的的求最后加入就好了代码如下：

protected void onDraw(Canvas canvas) {
    ...
    mPaint.setTextAlign(Paint.Align.CENTER);
    int drawnSelectedPos = - mScrollOffsetY / mItemHeight;
    for (int drawDataPos = drawnSelectedPos - mHalfVisibleItemCount - 1;drawDataPos <= drawnSelectedPos + mHalfVisibleItemCount + 1; drawDataPos++) {
        ...
        canvas.drawText(data.toString(), mFirstItemDrawX, itemDrawY, mPaint);
    }
    
    mPaint.setTextAlign(Paint.Align.LEFT);
    canvas.drawText(mIndicatorText, mFirstItemDrawX + mTextMaxWidth / 2, mCenterItemDrawnY, mPaint);
}
复制代码

###小结 到此，一个滚轮选择器主要功能就已现现了。接下来只要完善一些细节部分比如监听器，点击效果等部分，就完成了。接下来根据需要利用滚轮选择器就能很轻松的实现日期选择器，省市选择器等控件。

详细代码请加群获取：### 有兴趣的朋友可以留言讨论或者加群交流技术【Android技术交流】：jq.qq.com/?_wv=1027&a…。进群有免费领取安卓进阶学习视频，源码，面试资料，群内有大牛一起交流讨论技术；点击链接加入群聊（包括java基础与原理，自定义控件、NDK、架构设计、混合式开发(Flutter，Weex)、性能优化、完整商业项目开发等）

weixin_34324081
关注
android自定义滚轴选择器_android自定义滚动选择器（二）
weixin_36311421的博客
02-22 712
在android自定义滚动选择器(一)这篇文章中，我们已经阐述了滚动选择器的实现原理以及准备事项，本篇文章将会从代码的角度一步步来实现该滚动选择器。如果来不及阅读文章，或者想直接获取源码，见git：android自定义滚动选择器ScrollPickerView的实现ScrollPickerView这个是我们的主视图，说白了就是我们的滚动选择器，本小节先来阐述下其代码实现。首先，我们要将Scroll...
android基于ListView实现的滚轮选择器
06-29
一个android基于ListView实现的滚轮选择器，简简单单一个class就行了,当然效果还有写不足，拿去用的话要根据自己的要求优化下
Android滚轮时间选择器(四种选择模式，年月日时分，年月日，时分，月日时分)DEMO(亲测有效)
03-14
Android滚轮时间选择器(四种选择模式，年月日时分，年月日，时分，月日时分)，蓝白风格，控件含确认和取消按钮
android滚轮选择器
08-24
自定义滚轮选择器，底部弹出
android时间滚动选择器
09-07
android 很漂亮很实用的时间滚动选择器，直接可以用，代码类简单美观。 ----------------------------------------------------------------------------------------------
Android 滚轮选择器JFPicker，推荐自己的一个开源库
weixin_43864176的博客
06-15 1967
Android 滚轮选择器
Android滚轮选择时间控件使用详解
08-31
这篇教程主要关注的是如何在Android应用中实现美观且高效的滚轮选择器，特别是自定义滚轮选择时间控件。 首先，Android系统自带的`TimePicker`控件在视觉效果上可能无法满足所有设计需求，因此开发者经常需要自定义...
3DWheelPicker:Android 数据选择器，支持3D滚轮滚动效果，支持各种时间选择，城市选择，普通数据选择，级联数据选择
05-28
时间选择 单数组的数据选择 多数组的数据选择（支持多级联） 省市区级联城市选择（城市数据可能不完整） 可动态设置样式 使用 在project的build.gradle添加如下代码 allprojects { repositories { ... maven { ...
Android 仿IOS3D滚轮选择器
04-14
- 在Android中，可以使用自定义View或者RecyclerView等组件来实现3D滚轮选择器。 - 通过监听用户的触摸事件，结合动画效果来模拟3D滚动，可能涉及到矩阵变换、视图层级关系的调整等技术。 - 数据绑定通常使用...
Android案例页面底部弹框PopupWindow+竖直滑动选择器WheelView的实现
04-19
`PopupWindow`常用于创建底部弹出框，而`WheelView`则是一个可滚动的选择器，通常用于日期选择、时间选择等场景。下面将详细介绍这两个组件的使用方法以及如何将它们结合在实际应用中。 ### 1. PopupWindow详解 `...
Android自定义滚轮式日期（时间）选择控件
03-23
可以同时显示日期加时间，或者只显示日期
安卓底部滚轮选择器
03-09
安卓底部滚轮选择器，eclipse代码
android滚轮，可实现日期，文字，时间滚动选择
08-16
android滚轮，可实现日期，文字，时间滚动选择
滚轮效果View的日期选择器和时间选择器和对话框（eclipse和Android studio两个版本）
07-17
滚轮效果View的日期选择器和时间选择器和对话框 滚轮效果View的日期选择器和时间选择器和对话框
详解Android中Handler的内部实现原理
09-03
Handler是Android系统中用于线程间通信的关键组件，它的内部实现原理涉及到Thread、MessageQueue和Looper等核心类。首先，我们需要理解线程在操作系统中的基本概念，线程是程序执行的最小单位，每个线程都有自己的...
android滚轮选择器详细教程
crazychen的专栏
12-16 9134
最近在学习自定义android控件，碰上了滚动选择器的效果，自己找来了别人代码，一眼看上去晕头转向（因为缺少经验），第二天静下心来，才能透过现象看本质，觉得写一篇博文帮助其他同学。 下面先看效果图 何为本质，就是思路，我一开始看到这个就懵了，没有思路，后来看了别人的代码，才明白是怎么一回事，凭着自己的理解，居然非常顺利的就写出来了。 思路：1，布局，整个控件的布局，其实就是用代码取带
开源项目安卓滚轮选择器WheelPicker的简单使用
wei的博客
08-31 3055
Android开源项目滚轮选择器WheelPicker
Android 使用WheelPicker自定义日期滚轮选择器
最新发布
weixin_47118034的博客
04-24 857
谷歌自带的NumberPicker局限多，不好用？试试看WheelPicker，拥有更多的自定义风格，能更好更便捷的实现各种你想要的效果。试过后是真香，快来学习学习。
自定义Android滚轮时间选择控件详解及实现
本文将重点介绍如何通过自定义控件实现一个可扩展的滚轮时间选择控件，结合使用开源库`WheelView`来满足不同的时间选择场景，包括但不限于选择完整的日期和时间、特定的身份证到期日期选择以及不同展示模式（如显示...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值