自定义控件 - 切换开关：SwitchView

自定义控件一般的几个步骤：
1.初始化相关背景图片，布局文件，自定义属性
2.设置控件宽高OnMeasure()
3.布局或者排版OnLayout()
4.绘制控件OnDraw()
5.处理触摸事件OnTouchEvent()

 public class SwitchView extends View implements View.OnTouchListener {

     //开关状态图片
     private Bitmap mSwitch_on, mSwitch_off, mSwitch_circle;

     //开关状态 默认关闭
     private boolean mCurrentState = false;

     //开关切换回调接口
     private OnSwitchChangedListener mOnSwitchChangedListener;

     //X轴按下坐标
     private int downX;
     //X轴移动时触点坐标
     private int moveX;
     //X轴偏移量
     private int left = 0;
     //最大可移动距离
     private int max;

     public SwitchView(Context context) {
         super(context);
         init();
     }

     public SwitchView(Context context, AttributeSet attrs) {
         super(context, attrs);
         init();
     }

     public SwitchView(Context context, AttributeSet attrs, int defStyle) {
         super(context, attrs, defStyle);
         init();
     }

     //1 初始化图片（加载）
     private void init() {
         Resources resr = getResources();
         mSwitch_on = BitmapFactory.decodeResource(resr, R.mipmap.switch_on);
         mSwitch_off = BitmapFactory.decodeResource(resr, R.mipmap.switch_off);
         mSwitch_circle = BitmapFactory.decodeResource(resr, R.mipmap.switch_circle);
         setOnTouchListener(this);
     }

     //2 设置控件宽高（测量）
     @Override
     protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
         int widthSize = mSwitch_off.getWidth();
         int heightSize = mSwitch_off.getHeight();
         max = mSwitch_off.getWidth() - mSwitch_circle.getWidth();
         setMeasuredDimension(widthSize, heightSize);
     }

     //3 布局（排版）
     @Override
     protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
         super.onLayout(changed, left, top, right, bottom);
     }

     //4 最后绘制控件
     @Override
     protected void onDraw(Canvas canvas) {
         super.onDraw(canvas);
         Matrix m = new Matrix();
         Paint p = new Paint();
         if (mCurrentState) {
             canvas.drawBitmap(mSwitch_on, m, p);
         } else {
             canvas.drawBitmap(mSwitch_off, m, p);
         }
         canvas.drawBitmap(mSwitch_circle, left, 0, p);
     }

     //5 触摸事件
     @Override
     public boolean onTouch(View v, MotionEvent event) {
         switch (event.getAction()) {
             case MotionEvent.ACTION_DOWN:
                 downX = (int) event.getX();//初始X轴按下坐标
                 break;
             case MotionEvent.ACTION_MOVE:
                 moveX = (int) event.getX();
                 left = moveX - downX;
                 if (!mCurrentState) {
                     //关闭状态边界处理
                     if (left < 0) {
                         left = 0;
                     } else if (left > max) {
                         left = max;
                     }
                 } else {
                     //开启状态边界处理
                     left = moveX - downX;
                     if (left > 0) {//向右滑
                         left = max;
                     } else if (Math.abs(left) > max) {
                         left = 0;
                     } else {
                         left = max - Math.abs(left);
                     }
                 }
                 break;
             case MotionEvent.ACTION_UP:
             case MotionEvent.ACTION_CANCEL://抬起时的判断
                 int upX = (int) event.getX();
                 boolean state = false; //滑动是否成功
                 //1 关闭状态
                 if (!mCurrentState) {
                     //滑动是否成功
                     //a 移动距离超过 1/2 的滑动宽度
                     //b 触摸点在滑动区域，开启按钮
                     state = (moveX - downX) >= max / 2 || upX >= max;
                     if (state) {
                         left = max;
                         mCurrentState = true;
                     } else {
                         left = 0;
                     }
                 } else {
                     //2 开启状态，判断滑动是否成功
                     //a 移动距离超过 1/2 的滑动宽度
                     //b 触摸点在滑动区域，关闭按钮
                     state = (downX - moveX) >= max / 2 || upX <= max;
                     if (state) {
                         left = 0;
                         mCurrentState = false;
                     } else {
                         left = max;
                     }
                 }
                 //滑动成功 且 回调接口不能空 触发回调方法
                 if (state && null != mOnSwitchChangedListener) {
                     mOnSwitchChangedListener.onSwitchChanged(mCurrentState);
                 }
                 break;
         }
         invalidate();
         return true;
     }

     //开关切换回调接口
     public interface OnSwitchChangedListener {
         void onSwitchChanged(boolean isOpen);
     }

     public void setOnSwitchChangedListener(OnSwitchChangedListener listener) {
         this.mOnSwitchChangedListener = listener;
     }

     public void setCurrentState(boolean isOpen) {
         mCurrentState = isOpen;
         left = isOpen ? max : 0;
         invalidate();
     }

 }