Android左右滑动控件实现开关的切换效果

/**
 * 开关控件，通过左右滑动控件实现开关的切换效果

 * 使用时需要设置开关状态监听{@link OnSwitchStateChangeListener}

 * 切换开关状态有2种方式:

 *

 * 1.{@link #on()}, {@link #off()}， 该方式分开操作， 并且带头动作动画

 *

 * 2.{@link #turn(boolean, boolean), 该方式通过传入布尔值控制开关以及是否显示切换动画

 *
 */
public class UISwitch extends View {

    /**
     * 用来监听开关状态变化的接口
     *
     */
    public interface OnSwitchStateChangeListener {

        public void onChange(boolean state);
    }

    /** 最大滑动时间 **/
    private static final int MAX_SETTLE_DURATION = 5000;

    private static final int MESSAGE_SCROLL = 1;

    private static final int DEFAULE_TRACKER_NEXT = 600;

    /** 开， 关， 按钮 **/
    private Bitmap on, off, handle;

    private Paint mPaint;

    private Paint handlePaint;

    private Scroller mScroll;

    private VelocityTracker mVelocityTracker;

    private OnSwitchStateChangeListener l;

    private int width, height;

    private int mLastX;

    /** 滑动偏移量 **/
    private int mOffset;
    /** 最大最小偏移 **/
    private int mMaxOffset, mMinOffset;

    /** 开关状态 **/
    private boolean mState;
    
    private boolean mOnEnable;

    /** 是否进行了拖拽 **/
    private boolean mIsBeingDragged;

    /** 触摸优化 **/
    private int mTouchSlop;

    private int drawableIds[] = new int[] { R.drawable.switch_btn_on,
            R.drawable.switch_btn_off, R.drawable.switch_btn_handle };

    /** 滑动事件 **/
    private Handler scrollHandler = new Handler() {

        @Override
        public void handleMessage(Message msg) {
            if (mScroll.computeScrollOffset()) {

                final int currX = mScroll.getCurrX();
                final int finalX = mScroll.getFinalX();

                if (finalX >= 0) {
                    mOffset -= currX;
                } else {
                    mOffset += -currX;
                }

                // 校验偏移量
                mOffset = Math.min(Math.max(mMinOffset, mOffset), mMaxOffset);

                sendEmptyMessage(msg.what);

                invalidate();

            }
        }
    };

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

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

    public UISwitch(Context context, AttributeSet attrs, int defStyle) {
        super(context, attrs, defStyle);

        TypedArray a = context.obtainStyledAttributes(attrs,
                R.styleable.UISwitch, defStyle, 0);

        if (a != null) {
            drawableIds[0] = a.getResourceId(
                    R.styleable.UISwitch_ui_switch_on_src,
                    R.drawable.switch_btn_on);
            drawableIds[1] = a.getResourceId(
                    R.styleable.UISwitch_ui_switch_off_src,
                    R.drawable.switch_btn_off);
            drawableIds[2] = a.getResourceId(
                    R.styleable.UISwitch_ui_switch_handle_src,
                    R.drawable.switch_btn_handle);

            mState = a.getBoolean(R.styleable.UISwitch_ui_switch_state, false);

            a.recycle();
        }
        init(context);

    }

    private void init(Context context) {

        on = getBitmapFor(drawableIds[0]);
        off = getBitmapFor(drawableIds[1]);
        handle = getBitmapFor(drawableIds[2]);

        mScroll = new Scroller(context, new AccelerateInterpolator());

        final ViewConfiguration configuration = ViewConfiguration.get(context);
        mTouchSlop = ViewConfigurationCompat
                .getScaledPagingTouchSlop(configuration);

        mPaint = new Paint();
        mPaint.setAntiAlias(true);
        mPaint.setDither(true);
        mPaint.setFilterBitmap(true);

        handlePaint = new Paint();
        handlePaint.setAntiAlias(true);
        handlePaint.setDither(true);
        handlePaint.setFilterBitmap(true);

        setClickable(true);
    }

    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {

        if (on == null || off == null || handle == null) {
            throw new RuntimeException("invalid image resources");
        }

        width = Math.max(Math.max(on.getWidth(), off.getWidth()),
                handle.getWidth());
        height = Math.max(Math.max(on.getHeight(), off.getHeight()),
                handle.getHeight());

        setMeasuredDimension(width, height);

        mMinOffset = 0;
        mMaxOffset = width - handle.getWidth();

        setState(mState);

        // final int newW = MeasureSpec.makeMeasureSpec(width,
        // MeasureSpec.EXACTLY);
        // final int newH = MeasureSpec.makeMeasureSpec(height,
        // MeasureSpec.EXACTLY);
        //
        // super.onMeasure(newW, newH);

    }

    @Override
    protected void onDraw(Canvas canvas) {

        final Bitmap bmp = Bitmap.createBitmap(width, height, Config.ARGB_8888);

        final Canvas c = new Canvas(bmp);

        // 画开图像
        c.drawBitmap(on, getSwitchLeft() - on.getWidth() + handle.getWidth()
                + mOffset, getSwitchTop(), mPaint);

        // 画关图像
        c.drawBitmap(off, getSwitchLeft() + mOffset, getSwitchTop(), mPaint);

        // 画把手
        c.drawBitmap(handle, getSwitchLeft() + mOffset, getSwitchTop(),
                handlePaint);

        // 圆角处理
        // canvas.drawBitmap(bmp, m, mPaint);
        canvas.drawBitmap(toRoundCorner(bmp, bmp.getHeight() / 2),
                getSwitchLeft(), getSwitchTop(), mPaint);
    }

    /**
     * 设置开关资源图片
     *
(the bitmap array sequence must be 'on', 'off', 'handle')
     *
     * @param bmp
     */
    public void setResourceBitmaps(Bitmap bmp[]) {
        if (bmp == null) {
            throw new NullPointerException("the resource bitmap do not null");
        }
        
        if (bmp.length != 3) {
            throw new ArrayIndexOutOfBoundsException("the resource bitmap array length must be 3");
        }

        on = bmp[0];
        off = bmp[1];
        handle = bmp[2];

        width = Math.max(Math.max(on.getWidth(), off.getWidth()),
                handle.getWidth());
        height = Math.max(Math.max(on.getHeight(), off.getHeight()),
                handle.getHeight());
        
        onMeasure(0, 0);
        
        invalidate();
    }

    @Override
    public boolean onTouchEvent(MotionEvent event) {

        // 如果速度监听对象为空
        if (mVelocityTracker == null) {
            // 获得该对象的实例
            mVelocityTracker = VelocityTracker.obtain();
        }

        mVelocityTracker.addMovement(event);

        final int action = event.getAction();
        final int currX = (int) MotionEventCompat.getX(event, 0);
        switch (action & MotionEventCompat.ACTION_MASK) {
        case MotionEvent.ACTION_DOWN:
            
            //不让父控件获取手势
            if (getParent() != null) {
                getParent().requestDisallowInterceptTouchEvent(true);
            }

            lightness(handlePaint, 0.9f);

            if (mScroll.computeScrollOffset()) {
                mScroll.abortAnimation();
            }

            mLastX = currX;

            break;

        case MotionEvent.ACTION_MOVE:

            final int dx = currX - mLastX;

            if (!mIsBeingDragged) {

                if (Math.abs(dx) > mTouchSlop / 4) {
                    mIsBeingDragged = true;
                }
            } else {
                mOffset += currX - mLastX;

                // 校验偏移量
                mOffset = Math.min(Math.max(mMinOffset, mOffset), mMaxOffset);

                mLastX = currX;
            }

            break;

        case MotionEvent.ACTION_UP :
            
            //不让父控件获取手势
            if (getParent() != null) {
                getParent().requestDisallowInterceptTouchEvent(false);
            }

            final VelocityTracker velocityTracker = mVelocityTracker;
            velocityTracker.computeCurrentVelocity(1000,
                    ViewConfiguration.get(getContext())
                            .getScaledMaximumFlingVelocity());
            int initialVelocity = (int) VelocityTrackerCompat.getXVelocity(
                    velocityTracker, 0);

            if (Math.abs(initialVelocity) > DEFAULE_TRACKER_NEXT
                    || !mIsBeingDragged) {

                if (!mIsBeingDragged) {
                    initialVelocity = 0;
                }

                turn(!mState, initialVelocity);

            } else {

                final int halfOffset = mMaxOffset / 2;

                turn(mOffset > halfOffset, 0);
            }

            mIsBeingDragged = false;

            if (mVelocityTracker != null) {
                // 回收资源
                mVelocityTracker.recycle();

                mVelocityTracker = null;

            }

            lightness(handlePaint, 1f);

            break;
        }

        invalidate();

        return super.onTouchEvent(event);
    }

    /**
     * 通过提供一个起点和直线距离开始滑动
     *
     * @param startx
     *            起点x坐标
     * @param starty
     *            起点y坐标
     * @param dx
     *            x距离
     * @param dy
     *            y距离
     * @param duration
     *            持续滑动时间
     */
    private void startScroll(int startx, int starty, int dx, int dy,
            int duration) {
        mScroll.startScroll(startx, starty, dx, dy, duration);

        scrollHandler.removeMessages(MESSAGE_SCROLL);
        scrollHandler.sendEmptyMessage(MESSAGE_SCROLL);

    }

    /**
     * 获取滑动持续时间
     *
     * @param dx
     *            滑动距离
     * @param velocity
     *            滑动速度
     * @return
     */
    private int getScrollDuration(int dx, int velocity) {

        final int width = getWidth();
        final int halfWidth = width / 2;
        final float distanceRatio = Math.min(1f, 1.0f * Math.abs(dx) / width);
        final float distance = halfWidth + halfWidth
                * distanceInfluenceForSnapDuration(distanceRatio);

        int duration = 0;
        velocity = Math.abs(velocity);
        if (velocity > 0) {
            duration = 4 * Math.round(1000 * Math.abs(distance / velocity));
        } else {
            duration = Math.abs(dx) * 4;
        }
        duration = Math.min(duration, MAX_SETTLE_DURATION);

        return duration;
    }

    // We want the duration of the page snap animation to be influenced by the
    // distance that
    // the screen has to travel, however, we don't want this duration to be
    // effected in a
    // purely linear fashion. Instead, we use this method to moderate the effect
    // that the distance
    // of travel has on the overall snap duration.
    private float distanceInfluenceForSnapDuration(float f) {
        f -= 0.5f; // center the values about 0.
        f *= 0.3f * Math.PI / 2.0f;
        return (float) Math.sin(f);
    }

    /**
     * 将图片设置为圆角
     */
    private Bitmap toRoundCorner(Bitmap bitmap, int pixels) {
        final Bitmap output = Bitmap.createBitmap(bitmap.getWidth(),
                bitmap.getHeight(), Config.ARGB_8888);
        final Canvas canvas = new Canvas(output);
        final Rect rect = new Rect(0, 0, bitmap.getWidth(), bitmap.getHeight());
        final RectF rectF = new RectF(rect);
        final Paint paint = new Paint();
        paint.setAntiAlias(true);
        paint.setDither(true);
        canvas.drawARGB(0, 0, 0, 0);
        canvas.drawRoundRect(rectF, pixels, pixels, paint);
        paint.setXfermode(new PorterDuffXfermode(Mode.SRC_IN));
        canvas.drawBitmap(bitmap, rect, rect, paint);
        paint.setStyle(Paint.Style.STROKE);
        paint.setStrokeWidth(0);
        paint.setStrokeCap(Cap.ROUND);
        paint.setStrokeJoin(Join.ROUND);
        canvas.drawRoundRect(rectF, pixels, pixels, paint);

        return output;
    }

    /**
     * 获取资源位图
     *
     * @param resId
     * @return
     */
    private Bitmap getBitmapFor(int resId) {
        Options op = new Options();
        op.inScaled = true;
        Bitmap bmp = BitmapFactory.decodeResource(getResources(), resId, op);
        return bmp;
    }
    
    @Override
    public void setEnabled(boolean enabled) {
        setClickable(false);
        setFocusable(false);
        super.setEnabled(enabled);
    }

    /**
     * 开关开启,含有切换效果
     */
    public void on() {
        turn(true, 0);
    }

    /**
     * 开关关闭,含有切换效果
     */
    public void off() {
        turn(false, 0);
    }

    /**
     * 开关操作
     *
     * @param on
     * @param smoothScroll
     *            True to smoothly scroll to the new item, false to transition
     *            immediately
     */
    public void turn(boolean on, boolean smoothScroll) {
        if (smoothScroll) {
            turn(on, 0);
        } else {
            setState(on);
        }
    }

    /**
     * 开关操作,含有切换效果
     *
     * @param on
     *            true/false, 开/关, on/off
     * @param vx
     *            切换速度, 0为系统默认
     */
    private void turn(boolean on, int vx) {
        int distance;

        if (on) {
            distance = mOffset - mMaxOffset;
        } else {
            distance = mOffset;
        }

        if (on != mState) {
            if (l != null) {
                l.onChange(on);
            }
        }

        mState = on;

        if (mScroll.computeScrollOffset()) {
            mScroll.abortAnimation();
        }

        startScroll(0, 0, distance, 0, getScrollDuration(distance, vx));
    }

    /**
     * 设置开关状态,无状态切换动画
     */
    private void setState(boolean state) {

        if (state != mState) {
            if (l != null) {
                l.onChange(state);
            }
        }

        mState = state;

        if (state) {
            mOffset = mMaxOffset;
        } else {
            mOffset = 0;
        }

        invalidate();
    }

    /***
     * 设置开关状态变化事件
     *
     * @param l
     */
    public void setOnStateChangeListener(OnSwitchStateChangeListener l) {
        this.l = l;
    }

    private int getSwitchLeft() {
        return 0;
    }

    private int getSwitchRight() {
        return width;
    }

    private int getSwitchTop() {
        return 0;
    }

    private int getSwitchBottom() {
        return height;
    }

    /**
     * 调整画笔亮度
     *
     * @param paint
     *            画笔
     * @param light
     *            亮度单位 , 正常为1f, 范围0f - 2f
     */
    private void lightness(Paint paint, float light) {
        final ColorMatrix cm = new ColorMatrix();

        cm.setScale(light, light, light, 1);

        paint.setColorFilter(new ColorMatrixColorFilter(cm));
    }

}