最近撸了一个自定义view，还是比较复杂的，感觉有必要分享下实现的过程。

效果

先来看下效果吧：

我们来分析这个view需要实现哪些效果。

首先它有一个刻度尺代表了时间段（也可以是别的什么），并且可以看到完整的刻度尺是比屏幕宽度大的，因此肯定需要可以左右滑动。
其次，可以有不可选的区域（gif中灰色块）和选中的区域（gif中蓝色块），点击刻度的空白位置出现或者移动选中区域到点击位置。
点击并拖动选中的区域可以移动，当移动到屏幕两边的时候，下层的刻度也能跟着移动。
还可以点击并拖动选中区域右边的白色小圆改变选中区域的大小，同样到达屏幕边界时下层刻度跟着移动。
当选中区域与不可选区域重叠时，选中区域变色。
选中区域最小为1个刻度，当移动后手指抬起时，选中区域贴合刻度。
最后还需要监听一些状态的变化，如是否重叠，选中区域改变的位置。

实现

刻度尺

别害怕有这么多的功能，我们一个一个来实现。首先是刻度尺，这个简单。由于完整的刻度尺是比屏幕宽度大的，因此我们先来了解几个概念：

这里手机屏幕的宽度是width，刻度尺的宽度的时maxWidth，我们其实只需要绘制手机屏幕可见的部分就可以了，这里的offset表示手机屏幕的左边与刻度尺左边的偏移量。

了解了这个概念，我们就来开始写吧，定义一个View，处理下构造都指向3个参数的那个，然后统一做初始化：

public class SelectView extends View {
    private final int DEFAULT_HEIGHT = dp2px(100);//wrap_content高度
    private Paint mPaint;

    public int dp2px(final float dpValue) {
        final float scale = getContext().getResources().getDisplayMetrics().density;
        return (int) (dpValue * scale + 0.5f);
    }

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

    public SelectView(Context context, @Nullable AttributeSet attrs) {
        this(context, attrs, 0);
    }

    public SelectView(Context context, @Nullable AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
        scroller = new OverScroller(context);
        init();
    }

    private void init() {
        mPaint = new Paint();
        mPaint.setAntiAlias(true);
        mPaint.setTextSize(textSize);
    }

    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        int widthMode = MeasureSpec.getMode(widthMeasureSpec);
        int widthSize = MeasureSpec.getSize(widthMeasureSpec);
        width = widthSize;
        int heightMode = MeasureSpec.getMode(heightMeasureSpec);
        int heightSize = MeasureSpec.getSize(heightMeasureSpec);
        if (heightMode == MeasureSpec.EXACTLY) {
            height = heightSize;
        } else {
            height = DEFAULT_HEIGHT;//wrap_content的高
        }
        setMeasuredDimension(width, height);
    }
}

我们在onMeasure中处理了wrap_content的高度。然后在onSizeChanged中获取尺寸参数：

    private int width;//控件宽度
    private int height;//控件高度
    private int maxWidth;//最大内容宽度
    private int totalWidth;//刻度整体宽度(最后一个刻度的文字在刻度外)
    private int minOffset = 0;
    private int maxOffset;
    private int offset = minOffset;//可视区域左边界与整体内容左边界的偏移量

    @Override
    protected void onSizeChanged(int w, int h, int oldw, int oldh) {
        super.onSizeChanged(w, h, oldw, oldh);
        totalWidth = titles.length * space;
        maxWidth = totalWidth - space;
        maxOffset = totalWidth - width;
        if (maxOffset < 0) {
            maxOffset = 0;
        }
        areaTop = (1 - areaRate) * height;
    }

接着就开始绘制吧：

    private String[] titles = {"09:00", "09:30", "10:00", "10:30", "11:00",
            "11:30", "12:00", "12:30", "13:00", "13:30",
            "14:00", "14:30", "15:00", "15:30", "16:00",
            "16:30", "17:00", "17:30", "18:00"};
    private int space = dp2px(40);//刻度间隔
    private int lineWidth = dp2px(1);//刻度线的宽度
    private int textSize = dp2px(12);
    private int textMargin = dp2px(8);//文字与长刻度的margin值
    private int rate = 1;   //短刻度与长刻度数量的比例(>=1)
    private float lineRate = 0.4f;//短刻度与长刻度长度的比例(0.0~1.0)

    @Override
    protected void onDraw(Canvas canvas) {
        super.onDraw(canvas);
        drawLine(canvas);
    }

    private void drawLine(Canvas canvas) {
        mPaint.setStyle(Paint.Style.STROKE);
        mPaint.setStrokeWidth(lineWidth);
        mPaint.setColor(Color.BLACK);
        canvas.drawLine(0, height, width, height, mPaint);
        for (int i = 0; i < titles.length; i++) {
            int position = i * space;
            if (position >= offset && position <= offset + width) {//判断是否可以显示在屏幕中
                int x = position - offset;
                if (i % (rate + 1) == 0) {//绘制长刻度
                    canvas.drawLine(x, 0, x, height, mPaint);

                    mPaint.setStyle(Paint.Style.FILL);
                    canvas.drawText(titles[i], x + textMargin, textSize, mPaint);
                    mPaint.setStyle(Paint.Style.STROKE);
                } else {//绘制短刻度
                    canvas.drawLine(x, height * (1 - lineRate), x, height, mPaint);
                }
            }
        }
    }

这里的titles代表了刻度的标识，每一个元素代表一个刻度（这里我字节写死了，实际上可以通过方法set，也不一定是时间，能代表刻度的都可以）。通过rate设置长短刻度的比例，这里我设置了1：1。运行一下看看，目前仅仅能看到从0开始，看不到完整的刻度尺，我们需要实现touch事件产生移动才有效果。

实现滑动刻度尺

我们重写onTouchEvent来实现滑动效果：

    private float downX, downY;
    private float lastX;//滑动上一个位置
  
    @Override
    public boolean onTouchEvent(MotionEvent event) {
        int action = event.getAction();
        switch (action) {
            case MotionEvent.ACTION_DOWN:
                downX = event.getX();
                lastX = downX;
                break;
            case MotionEvent.ACTION_MOVE:
                float x = event.getX();
                float dx = x - lastX;
                changeOffsetBy(-dx);
                lastX = x;
                postInvalidate();
                break;
            case MotionEvent.ACTION_UP:
            case MotionEvent.ACTION_CANCEL:
               
                break;
            default:
                break;
        }
        return true;
    }

    private void changeOffsetBy(float dx) {
        offset += dx;
        if (offset < minOffset) {
            offset = minOffset;
        } else if (offset > maxOffset) {
            offset = maxOffset;
        }
    }

我们计算出每次move事件的X方向的变化量dx，然后通过这个dx改变offset，并且处理一下边界的情况。然后调用postInvalidate刷新界面。运行一下看看！现在我们可以滑动刻度尺了。但是好像还有点问题，平时我们使用ScrollView的时候用力划一下，可以看到手指离开了屏幕，但是内容还可以继续滚动。而目前我们自定义的这个view只能通过手指滑动，如果手指离开屏幕就不能滑动了。这样的体验显然不够好，我们来实现这个惯性滑动的效果吧！

实现惯性滑动

要实现惯性滑动，我们需要用到两个类：VelocityTracker，OverScroller。
VelocityTracker简介 android view滑动助手类OverScroller

    private int minFlingVelocity;//最小惯性滑动速度
    private VelocityTracker velocityTracker;
    private OverScroller scroller;
    private int lastFling;//惯性滑动上一个位置
    
    private void init(Context context) {
        ...
        scroller = new OverScroller(context);
        minFlingVelocity = ViewConfiguration.get(getContext()).getScaledMinimumFlingVelocity();
    }

    @Override
    public boolean onTouchEvent(MotionEvent event) {
        if (velocityTracker == null) {
            velocityTracker = VelocityTracker.obtain();
        }
        velocityTracker.addMovement(event);

         int action = event.getAction();
        switch (action) {
            case MotionEvent.ACTION_DOWN:
                scroller.forceFinished(true);
                downX = event.getX();
                lastX = downX;
                break;
            case MotionEvent.ACTION_MOVE:
                float x = event.getX();
                float dx = x - lastX;
                changeOffsetBy(-dx);
                lastX = x;
                postInvalidate();
                break;
            case MotionEvent.ACTION_UP:
            case MotionEvent.ACTION_CANCEL:
                 //处理惯性滑动
                velocityTracker.computeCurrentVelocity(1000, 8000);
                float xVelocity = velocityTracker.getXVelocity();
                if (Math.abs(xVelocity) > minFlingVelocity) {
                    scroller.fling(0, 0, (int) xVelocity, 0, Integer.MIN_VALUE,
                        Integer.MAX_VALUE, 0, 0);
                }
                velocityTracker.clear();
                break;
            default:
                break;
        }
        return true;
    }

    @Override
    public void computeScroll() {
        if (scroller.computeScrollOffset()) {
            int currX = scroller.getCurrX();
            float dx = currX - lastFling;
            //已经在边界了，不再处理惯性
            if ((offset <= minOffset && dx > 0) || offset >= maxOffset && dx < 0) {
                scroller.forceFinished(true);
                return;
            }
            changeOffsetBy(-dx);
            lastFling = currX;
            postInvalidate();
        } else {
            lastFling = 0;//重置上一次值，避免第二次惯性滑动计算错误的dx
        }
    }

velocityTracker.computeCurrentVelocity方法的第二个参数表示最大惯性速度，这里我设置8000，避免刻度尺过快的滑动。通过调用scroller.fling方法将计算出的速度交给scroller，然后在computeScroll方法中获取当前值，并与上一次的值做差算出变化量dx，同样用这个dx变化offset刷新界面实现滑动效果。

不可选区域

刻度尺完成了，接下来是不可选的灰色区域。我采用两个int值表示在刻度尺的区域，刻度尺的每个刻度表示一个最小单位，前一个int表示在刻度尺的起始位置，后一个int表示占据的刻度数量。

    private List<int[]> unselectableList = new ArrayList<>();
    private List<RectF> unselectableRectFs = new ArrayList<>();
    private RectF tempRect = new RectF();

    @Override
    protected void onDraw(Canvas canvas) {
        super.onDraw(canvas);
        drawLine(canvas);
        drawUnselectable(canvas);
    }

    private void drawUnselectable(Canvas canvas) {
        generateUnselectableRectFs();
        mPaint.setStyle(Paint.Style.FILL);
        mPaint.setColor(Color.parseColor("#99878787"));
        for (RectF rectF : unselectableRectFs) {
            float left = Math.max(rectF.left, offset) - offset;
            float right = Math.min(rectF.right, offset + width) - offset;
            tempRect.set(left, rectF.top, right, rectF.bottom);
            canvas.drawRect(tempRect, mPaint);
        }
    }

    private void generateUnselectableRectFs() {
        //避免重复生成
        if (unselectableRectFs.size() > 0 
                && unselectableList.size() == unselectableRectFs.size()) {
            return;
        }
        unselectableRectFs.clear();
        for (int[] ints : unselectableList) {
            int start = ints[0];
            int count = ints[1];
            int max = titles.length - 1;
            if (start > max || start + count > max) {
                throw new IllegalArgumentException("unselectable area has wrong start or count, " +
                        "the total limit is" + max);
            }
            if (count > 0) {
                unselectableRectFs.add(new RectF(start * space, areaTop,
                        (start + count) * space, height));
            }
        }
    }

    public void addUnseletable(int start, int count) {
        unselectableList.add(new int[]{start, count});
        postInvalidate();
    }

我用一个list存放设置的不可选区域，然后在另一个list中存放转换成RectF的位置信息。这里的RectF是在相对于整体刻度尺而言的，因此绘制到屏幕的时候需要减去offset，并且需要考虑只有部分在屏幕可见的情况。避免在onDraw方法中创建过多临时变量，我声明一个成员变量tempRect，用来保存绘制时的临时参数。

可选区域

完成了不可选区域，可选区域也是同样的。由于只能有一个可选区域，我们只需要定义一个RectF。额外需要考虑与不可选区域相交时会变色，我定了一个overlapping表示是否相交，通过RectF的intersects方法判断。

    private int selectedBgColor = Color.parseColor("#654196F5");
    private int selectedStrokeColor = Color.parseColor("#4196F5");
    private int overlappingBgColor = Color.parseColor("#65FF6666");
    private int overlappingStrokeColor = Color.parseColor("#FF6666");
    private int selectedStrokeWidth = dp2px(2);
    private int extendRadius = dp2px(7);//扩展圆的半径
    private float extendTouchRate = 1.5f;//扩展触摸区域与视图的比率(>=1)

    private boolean overlapping;//是否覆盖unselectable
    private RectF selectedRectF;//选择区域位置
    private RectF extendPointRectF;//扩展点位置

    @Override
    protected void onDraw(Canvas canvas) {
        super.onDraw(canvas);
        drawLine(canvas);
        drawUnselectable(canvas);
        drawSelected(canvas);
    }

    private void drawSelected(Canvas canvas) {
        if (selectedRectF == null) {
            return;
        }
        overlapping = checkOverlapping();
        float left = Math.max(selectedRectF.left, offset) - offset;
        float right = Math.min(selectedRectF.right, offset + width) - offset;
        tempRect.set(left, selectedRectF.top, right, selectedRectF.bottom);
        //填充
        mPaint.setStyle(Paint.Style.FILL);
        mPaint.setColor(overlapping ? overlappingBgColor : selectedBgColor);
        canvas.drawRect(tempRect, mPaint);
        //边框
        mPaint.setStyle(Paint.Style.STROKE);
        mPaint.setStrokeWidth(selectedStrokeWidth);
        mPaint.setColor(overlapping ? overlappingStrokeColor : selectedStrokeColor);
        canvas.drawRect(tempRect, mPaint);
        if ((selectedRectF.right - offset) == right) {
            //扩展圆边框
            mPaint.setColor(overlapping ? overlappingStrokeColor : selectedStrokeColor);
            canvas.drawCircle(tempRect.right, tempRect.centerY(), extendRadius, mPaint);
            //扩展圆填充
            mPaint.setColor(Color.WHITE);
            mPaint.setStyle(Paint.Style.FILL);
            canvas.drawCircle(tempRect.right, tempRect.centerY(), extendRadius, mPaint);
            //扩展圆的位置信息，处理touch事件需要
            extendPointRectF = new RectF(selectedRectF.right - extendRadius * extendTouchRate,
                    selectedRectF.centerY() - extendRadius * extendTouchRate,
                    selectedRectF.right + extendRadius * extendTouchRate,
                    selectedRectF.centerY() + extendRadius * extendTouchRate);
        } else {
            extendPointRectF = null;
        }
    }

    private boolean checkOverlapping() {
        if (selectedRectF != null) {
            for (RectF rectF : unselectableRectFs) {
                if (rectF.intersects(selectedRectF.left, selectedRectF.top,
                        selectedRectF.right, selectedRectF.bottom)) {
                    return true;
                }
            }
        }
        return false;
    }

点击，移动，扩展

通过前面的分析，我们知道这个view中的事件有很多种：点击，移动刻度尺，移动选中区域，扩展选中区域。我们定义这四种类型便于后续的事件处理：

    public static final int TYPE_MOVE = 1;
    public static final int TYPE_EXTEND = 2;
    public static final int TYPE_CLICK = 3;
    public static final int TYPE_SLIDE = 4;

然后改造一下onTouchEvent：

    private boolean linking;//是否正在联动
    private Handler handler = new BookHandler(this);
    private int boundary = space / 2;//屏幕边界范围

    private static class BookHandler extends Handler {
        private static final int DELAY_MILLIS = 10;//刷新率（0~16）
        private WeakReference<SelectView> selectViewWeakReference;

        BookHandler(SelectView selectView) {
            super();
            selectViewWeakReference = new WeakReference<>(selectView);
        }

        @Override
        public void handleMessage(Message msg) {
            SelectView view = selectViewWeakReference.get();
            if (view != null) {
                float dx = (float) msg.obj;
                view.changeOffsetBy(dx);
                if (msg.what == MESSAGE_EXTEND) {
                    float r = view.selectedRectF.right + dx;
                    view.resetSelectedRight(r);
                } else if (msg.what == MESSAGE_MOVE) {
                    float l = view.selectedRectF.left + dx;
                    float r = view.selectedRectF.right + dx;
                    view.resetSelectedRectF(l, r);
                }
                view.postInvalidate();
                if (view.linking) {
                    sendMessageDelayed(Message.obtain(msg), DELAY_MILLIS);
                }
            }
        }
    }

    @Override
    public boolean performClick() {
        return super.performClick();
    }

    @Override
    public boolean onTouchEvent(MotionEvent event) {
        if (velocityTracker == null) {
            velocityTracker = VelocityTracker.obtain();
        }
        velocityTracker.addMovement(event);

        int action = event.getAction();
        switch (action) {
            case MotionEvent.ACTION_DOWN:
                scroller.forceFinished(true);
                downX = event.getX();
                lastX = downX;
                downY = event.getY();
                checkTouchType();
                break;
            case MotionEvent.ACTION_MOVE:
                float x = event.getX();
                float dx = x - lastX;
                if (touchType == TYPE_EXTEND) {
                    handleExtend(dx);
                } else if (touchType == TYPE_MOVE) {
                    handleMove(dx);
                } else if (touchType == TYPE_SLIDE) {
                    changeOffsetBy(-dx);
                }
                lastX = x;
                postInvalidate();
                break;
            case MotionEvent.ACTION_UP:
            case MotionEvent.ACTION_CANCEL:
                float upX = event.getX();
                float upY = event.getY();
                if (Math.abs(upX - downX) < touchSlop && Math.abs(upY - downY) < touchSlop) {
                    touchType = TYPE_CLICK;
                    performClick();
                }

                handleActionUp(upX);
                break;
            default:
                break;
        }
        return true;
    }

    private void checkTouchType() {
        RectF extend = null;
        if (extendPointRectF != null) {
            extend = new RectF(extendPointRectF.left - offset, extendPointRectF.top,
                    extendPointRectF.right - offset, extendPointRectF.bottom);
            Timber.i("extend:" + extend.toString());
        }
        RectF selected = null;
        if (selectedRectF != null) {
            selected = new RectF(selectedRectF.left - offset, selectedRectF.top,
                    selectedRectF.right - offset, selectedRectF.bottom);
            Timber.i("selected:" + selected.toString());
        }

        if (extend != null && extend.contains(lastX, downY)) {
            touchType = TYPE_EXTEND;
        } else if (selected != null && selected.contains(lastX, downY)) {
            touchType = TYPE_MOVE;
        } else {
            touchType = TYPE_SLIDE;
        }
    }

    private void handleExtend(float dx) {
        //如果正在联动时，避免手指抖动造成不必要停止
        if (linking && Math.abs(dx) < touchSlop) {
            return;
        }
        float right = selectedRectF.right += dx;
        //下层联动
        Message message = null;
        if (dx > 0 && width - (right - offset) < boundary //选中区域滑到屏幕右边
                && offset < maxOffset) {
            message = handler.obtainMessage(MESSAGE_EXTEND, linkDx);
        } else if (dx < 0 && right > selectedRectF.left
                && right - offset < boundary && offset > minOffset) {
            message = handler.obtainMessage(MESSAGE_EXTEND, -linkDx);
        }
        if (message != null) {
            if (!linking) {
                linking = true;
                handler.sendMessage(message);
            }
        } else {
            stopLinking();
            resetSelectedRight(right);
        }
    }

    private void handleMove(float dx) {
        //如果正在联动时，避免手指抖动造成不必要停止
        if (linking && Math.abs(dx) < touchSlop) {
            return;
        }
        float left = selectedRectF.left += dx;
        float right = selectedRectF.right += dx;
        Message message = null;
        if ((dx < 0 && left - offset < boundary && offset > minOffset)) {//选中区域滑到屏幕左边并继续向左滑动
            message = handler.obtainMessage(MESSAGE_MOVE, -linkDx);
        } else if (dx > 0 && width - (right - offset) < boundary && offset < maxOffset) {//选中区域滑到屏幕右边并且继续向右滑动
            message = handler.obtainMessage(MESSAGE_MOVE, linkDx);
        }
        Timber.e("message:" + message);
        if (message != null) {//处在两边界，需要联动
            if (!linking) {
                linking = true;
                handler.sendMessage(message);
            }
        } else {
            stopLinking();
            resetSelectedRectF(left, right);
        }
    }

    private void handleActionUp(float upX) {
        if (touchType == TYPE_CLICK) {
            int start = (int) ((upX + offset) / space);
            int[] area = getSelected();
            setSelected(start, area == null ? CLICK_SPACE : area[1]);
        } else if (touchType == TYPE_EXTEND) {
            stopLinking();
            int right = Math.round(selectedRectF.right / space) * space;
            resetSelectedRight(right);
            postInvalidate();
        } else if (touchType == TYPE_MOVE) {
            stopLinking();
            int[] area = getSelected();
            if (area != null) {
                setSelected(area[0], area[1]);
            }
        } else if (touchType == TYPE_SLIDE) {
            //处理惯性滑动
            velocityTracker.computeCurrentVelocity(1000, 8000);
            float xVelocity = velocityTracker.getXVelocity();
            if (Math.abs(xVelocity) > minFlingVelocity) {
                scroller.fling(0, 0, (int) xVelocity, 0, Integer.MIN_VALUE,
                        Integer.MAX_VALUE, 0, 0);
            }
            velocityTracker.clear();
        }
    }

    private void stopLinking() {
        linking = false;
        handler.removeCallbacksAndMessages(null);
    }

    /**
     * 重置选择区域的位置
     *
     * @param left
     * @param right
     */
    private void resetSelectedRectF(float left, float right) {
        if (left < 0) {
            left = 0;
            right = selectedRectF.right - selectedRectF.left;
        }
        if (right > maxWidth) {
            right = maxWidth;
            left = maxWidth - (selectedRectF.right - selectedRectF.left);
        }
        int minSpace = minSelect * space;
        if (right - left < minSpace) {//最小值
            if (maxWidth - selectedRectF.left < minSpace) {
                right = maxWidth;
                left = maxWidth - minSpace;
            } else {
                right = selectedRectF.left + minSpace;
            }
        }
        selectedRectF.left = left;
        selectedRectF.right = right;
    }

    /**
     * 重置选择区域的right
     *
     * @param right
     */
    private void resetSelectedRight(float right) {
        if (right > maxWidth) {
            right = maxWidth;
        }
        int minSpace = minSelect * space;
        if (right - selectedRectF.left < minSpace) {//最小值
            if (maxWidth - selectedRectF.left < minSpace) {
                right = maxWidth;
                selectedRectF.left = maxWidth - minSpace;
            } else {
                right = selectedRectF.left + minSpace;
            }
        }
        selectedRectF.right = right;
    }

    /**
     * 将选择内容转换成区域
     *
     * @param start 开始位置
     * @param count 数量
     */
    public void setSelected(int start, int count) {
        if (start > titles.length - 1) {
            throw new IllegalArgumentException("wrong start");
        }
        int right = (start + count) * space;
        if (right > maxWidth) {
//            int cut = Math.round((right - maxWidth) * 1f / space);
//            start -= cut;//整体向左移动
            right = maxWidth;
        }
        int left = start * space;
        if (selectedRectF == null) {
            selectedRectF = new RectF(left, areaTop, right, height);
            if (selectChangeListener != null) {
                selectChangeListener.onSelected();
            }
        } else {
            selectedRectF.set(left, areaTop, right, height);
        }
        notifySelectChangeListener(start, count);
        postInvalidate();
    }

    /**
     * 将选中区域转换成选择内容
     *
     * @return [start, count]
     */
    public int[] getSelected() {
        if (selectedRectF == null) {
            return null;
        }
        int[] area = new int[2];
        float w = selectedRectF.right - selectedRectF.left;
        area[0] = Math.round(selectedRectF.left / space);
        area[1] = Math.round(w / space);
        return area;
    }

performClick会在你重写onTouchEvent时as提示你需要重写的方法，因为你可能没有考虑到如果给这个view设置OnClickListener的情况。如果你没有在onTouchEvent中调用performClick，那么setOnClickListener方法就失效了。

你可能注意到这一次比较复杂，并且还有一个linking字段，表示是否正在联动，我解释一下这个联动的概念：通过gif其实你可能注意到，当我移动或者扩展选中区域的时候，如果移动到了屏幕的边界，后面的刻度尺就会跟着移动，实际上这个时候选中区域在屏幕中的位置没有改变，只是刻度尺移动了。一开始我也是通过dx来改变offset，但是存在一个问题，移动到屏幕边缘之后，手指可以移动的区域已经很小了，不会产生足够的dx（手指不移动的话，不会有新的touch事件产生）。最好的体验是我把手机移动到屏幕边缘，刻度尺就会自己按照一定的速率移动直到最大offset或者最小offset。于是我使用了Handler，当满足条件后发送消息，表示开始进行联动，会按照固定速度产生一个dx改变offset。当然，在离开屏幕边缘的时候还需要及时取消handler的任务。

至此，功能基本已经实现了，运行一下看看效果吧~

后面需要做什么那？现在这个view只能自己玩，我需要它与其他view有交互，比如选中什么区域，状态的改变生么的。

状态变化

声明两个接口，并在适当时候回调它们的方法，这样外部就能感知view的状态变化。

    public interface OverlappingStateChangeListener {
        void onOverlappingStateChanged(boolean isOverlapping);
    }

    public interface SelectChangeListener {
        void onSelected();

        void onSelectChanged(int start, int count);
    }

完善

后面的话就是根据业务添加一些api了，例如添加不可选区域，改变刻度范围什么，一切都看需求了。

源码

最后附上代码：SelectView