手势解锁自定义View

 package com.rxx.view;

 import java.util.ArrayList;
 import java.util.List;
 import java.util.Timer;
 import java.util.TimerTask;
 import android.content.Context;
 import android.graphics.Canvas;
 import android.graphics.Color;
 import android.graphics.Paint;
 import android.graphics.Path;
 import android.util.AttributeSet;
 import android.view.MotionEvent;
 import android.view.View;

 /**
  * 自定义锁屏View
  */
 public class GestureLockView extends View {
     /** 解锁密码key */
     private String key = "";
     private OnGestureFinishListener onGestureFinishListener;

     /** 解锁圆点数组 */
     private LockCircle[] cycles;
     /** 存储触碰圆的序列 */
     private List<Integer> linedCycles = new ArrayList<Integer>();

     // 画笔
     /** 空心外圆 */
     private Paint paintNormal;
     /** 点击后内部圆 */
     private Paint paintInnerCycle;
     /** 画路径 */
     private Paint paintLines;
     private Path linePath = new Path();

     /** 当前手指X,Y位置 */
     private int eventX, eventY;

     /** 能否操控界面绘画 */
     private boolean canContinue = true;
     /** 验证结果 */
     private boolean result;
     private Timer timer;

     /** 未选中颜色 */
     private final int NORMAL_COLOR = Color.parseColor("#959BB4");
     /** 错误颜色 */
     private final int ERROE_COLOR = Color.parseColor("#FF2525"); // 正常外圆颜色
     /** 选中时颜色 */
     private final int TOUCH_COLOR = Color.parseColor("#409DE5"); // 选中内圆颜色

     // =================================start=构造方法========================
     public GestureLockView(Context context, AttributeSet attrs, int defStyle) {
         super(context, attrs, defStyle);
         init();
     }

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

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

     // ===============================end=构造方法========================

     /** 初始化 */
     public void init() {
         paintNormal = new Paint();
         paintNormal.setAntiAlias(true);
         paintNormal.setStrokeWidth(5);
         paintNormal.setStyle(Paint.Style.STROKE);

         paintInnerCycle = new Paint();
         paintInnerCycle.setAntiAlias(true);
         paintInnerCycle.setStyle(Paint.Style.FILL);

         paintLines = new Paint();
         paintLines.setAntiAlias(true);
         paintLines.setStyle(Paint.Style.STROKE);
         paintLines.setStrokeWidth(10);

     }

     @Override
     protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
         int specMode = MeasureSpec.getMode(widthMeasureSpec);
         int spceSize = MeasureSpec.getSize(widthMeasureSpec);
         heightMeasureSpec = MeasureSpec.makeMeasureSpec(
                 (int) (spceSize * 0.85 + 0.5f), specMode);
         super.onMeasure(widthMeasureSpec, heightMeasureSpec);
     }

     @Override
     protected void onLayout(boolean changed, int left, int top, int right,
             int bottom) {
         super.onLayout(changed, left, top, right, bottom);
         int perWidthSize = getWidth() / 7;
         int perHeightSize = getHeight() / 6;
         /** 初始化圆的参数 */
         if (cycles == null && (perWidthSize > 0) && (perHeightSize > 0)) {
             cycles = new LockCircle[9];
             for (int i = 0; i < 3; i++) {
                 for (int j = 0; j < 3; j++) {
                     LockCircle lockCircle = new LockCircle();
                     lockCircle.setNum(i * 3 + j);
                     lockCircle.setOx(perWidthSize * (j * 2 + 1.5f) + 0.5f);
                     lockCircle.setOy(perHeightSize * (i * 2 + 1) + 0.5f);
                     lockCircle.setR(perWidthSize * 0.6f);
                     cycles[i * 3 + j] = lockCircle;
                 }
             }
         }

     }

     public void setKey(String key) {
         this.key = key;
     }

     public void setOnGestureFinishListener(
             OnGestureFinishListener onGestureFinishListener) {
         this.onGestureFinishListener = onGestureFinishListener;
     }

     /** 手势输入完成后回调接口 */
     public interface OnGestureFinishListener {
         /** 手势输入完成后回调函数 */
         public void OnGestureFinish(boolean success, String key);
     }

     /** 监听手势 */
     @Override
     public boolean onTouchEvent(MotionEvent event) {
         if (canContinue) {
             switch (event.getAction()) {
             case MotionEvent.ACTION_DOWN:
             case MotionEvent.ACTION_MOVE:
                 eventX = (int) event.getX();
                 eventY = (int) event.getY();
                 for (int i = 0; i < cycles.length; i++) {
                     if (cycles[i].isPointIn(eventX, eventY)) {
                         cycles[i].setOnTouch(true);
                         if (!linedCycles.contains(cycles[i].getNum())) {
                             linedCycles.add(cycles[i].getNum());
                         }
                     }
                 }
                 break;
             case MotionEvent.ACTION_UP:
                 // 手指离开暂停触碰
                 canContinue = false;
                 StringBuffer stringBuffer = new StringBuffer();
                 for (int i = 0; i < linedCycles.size(); i++) {
                     stringBuffer.append(linedCycles.get(i));
                 }
                 result = key.equals(stringBuffer.toString());
                 if (onGestureFinishListener != null && linedCycles.size() > 0) {
                     onGestureFinishListener.OnGestureFinish(result,
                             stringBuffer.toString());
                 }
                 timer = new Timer();
                 timer.schedule(new TimerTask() {
                     @Override
                     public void run() {
                         eventX = eventY = 0;
                         for (int i = 0; i < 9; i++) {
                             cycles[i].setOnTouch(false);
                         }
                         linedCycles.clear();
                         linePath.reset();
                         canContinue = true;
                         postInvalidate();// 在非ui线程刷新界面
                     }
                 }, 1000);
                 break;
             }
             invalidate();
         }
         return true;
     }

     @Override
     protected void onDraw(Canvas canvas) {
         super.onDraw(canvas);
         int cycleSize = cycles.length;
         for (int i = 0; i < cycleSize; i++) {
             // 画完并且错误
             if (!canContinue && !result) {
                 if (cycles[i].isOnTouch()) {
                     drawInnerCycle(cycles[i], canvas, ERROE_COLOR);
                     drawOutsideCycle(cycles[i], canvas, ERROE_COLOR);
                 } else
                     drawOutsideCycle(cycles[i], canvas, NORMAL_COLOR);
             }
             // 绘画中
             else {
                 if (cycles[i].isOnTouch()) {
                     drawInnerCycle(cycles[i], canvas, TOUCH_COLOR);
                     drawOutsideCycle(cycles[i], canvas, TOUCH_COLOR);
                 } else
                     drawOutsideCycle(cycles[i], canvas, NORMAL_COLOR);
             }
         }

         if (!canContinue && !result) {
             drawLine(canvas, ERROE_COLOR);
         } else {
             drawLine(canvas, TOUCH_COLOR);
         }

     }

     /** 画空心圆 */
     private void drawOutsideCycle(LockCircle lockCircle, Canvas canvas,
             int color) {
         paintNormal.setColor(color);
         canvas.drawCircle(lockCircle.getOx(), lockCircle.getOy(),
                 lockCircle.getR(), paintNormal);
     }

     /** 画横线 */
     private void drawLine(Canvas canvas, int color) {
         // 构建路径
         linePath.reset();
         if (linedCycles.size() > 0) {
             int size = linedCycles.size();
             for (int i = 0; i < size; i++) {
                 int index = linedCycles.get(i);
                 float x = cycles[index].getOx();
                 float y = cycles[index].getOy();
                 if (i == 0) {
                     linePath.moveTo(x, y);
                 } else {
                     linePath.lineTo(x, y);
                 }
             }
             if (canContinue) {
                 linePath.lineTo(eventX, eventY);
             } else {
                 linePath.lineTo(
                         cycles[linedCycles.get(linedCycles.size() - 1)].getOx(),
                         cycles[linedCycles.get(linedCycles.size() - 1)].getOy());
             }
             paintLines.setColor(color);
             canvas.drawPath(linePath, paintLines);
         }
     }

     /** 画中心圆圆 */
     private void drawInnerCycle(LockCircle myCycle, Canvas canvas, int color) {
         paintInnerCycle.setColor(color);
         canvas.drawCircle(myCycle.getOx(), myCycle.getOy(),
                 myCycle.getR() / 3f, paintInnerCycle);
     }

     /**
      * 每个圆点类
      */
     class LockCircle {
         /** 圆心横坐标 */
         private float ox;
         /** 圆心纵坐标 */
         private float oy;
         /** 半径长度 */
         private float r;
         /** 代表数值 */
         private Integer num;
         /** 是否选择:false=未选中 */
         private boolean onTouch;

         public float getOx() {
             return ox;
         }

         public void setOx(float ox) {
             this.ox = ox;
         }

         public float getOy() {
             return oy;
         }

         public void setOy(float oy) {
             this.oy = oy;
         }

         public void setOy(int oy) {
             this.oy = oy;
         }

         public float getR() {
             return r;
         }

         public void setR(float r) {
             this.r = r;
         }

         public Integer getNum() {
             return num;
         }

         public void setNum(Integer num) {
             this.num = num;
         }

         public boolean isOnTouch() {
             return onTouch;
         }

         public void setOnTouch(boolean onTouch) {
             this.onTouch = onTouch;
         }

         /** 判读传入位置是否在圆心内部 */
         public boolean isPointIn(int x, int y) {
             double distance = Math.sqrt((x - ox) * (x - ox) + (y - oy)
                     * (y - oy));
             return distance < r;
         }
     }
 }

 <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
     android:layout_width="fill_parent"
     android:layout_height="fill_parent"
     android:background="#232736"
     android:gravity="center"
     android:orientation="vertical" >

     <!-- 小头像 -->
     <ImageView
         android:layout_width="70dp"
         android:layout_height="70dp"
         android:src="@drawable/tempfenlei" />

     <TextView
         android:id="@+id/textview"
         android:layout_width="wrap_content"
         android:layout_height="wrap_content"
         android:layout_marginTop="10dp"
         android:text=""
         android:textColor="#FF2525"
         android:textSize="16sp"
         android:visibility="invisible" />

     <com.rxx.view.GestureLockView
         android:id="@+id/gestureLockView"
         android:layout_width="wrap_content"
         android:layout_height="wrap_content" />

     <LinearLayout
         android:layout_width="fill_parent"
         android:layout_height="wrap_content"
         android:orientation="horizontal"
         android:padding="10dp" >

         <TextView
             android:layout_width="fill_parent"
             android:layout_height="wrap_content"
             android:layout_weight="1"
             android:gravity="center"
             android:text="管理手势密码"
             android:textColor="#585C6E"
             android:textSize="16sp" />

         <TextView
             android:layout_width="fill_parent"
             android:layout_height="wrap_content"
             android:layout_weight="1"
             android:gravity="center"
             android:text="登陆其他账号"
             android:textColor="#585C6E"
             android:textSize="16sp" />
     </LinearLayout>

 </LinearLayout>

 package com.rxx.gesturelockdemo;

 import android.app.Activity;
 import android.graphics.Color;
 import android.os.Bundle;
 import android.view.View;
 import android.view.animation.Animation;
 import android.view.animation.TranslateAnimation;
 import android.widget.TextView;

 import com.rxx.view.GestureLockView;
 import com.rxx.view.GestureLockView.OnGestureFinishListener;

 public class MainActivity extends Activity {

     private GestureLockView gestureLockView;
     private TextView textview;
     private Animation animation;

     @Override
     protected void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
         setContentView(R.layout.activity_main);
         init();
     }

     /** 初始化 */
     public void init() {
         gestureLockView = (GestureLockView) findViewById(R.id.gestureLockView);
         textview = (TextView) findViewById(R.id.textview);
         animation = new TranslateAnimation(-20, 20, 0, 0);
         animation.setDuration(50);
         animation.setRepeatCount(2);
         animation.setRepeatMode(Animation.REVERSE);
         // 设置密码
         gestureLockView.setKey("1");
         // 手势完成后回调
         gestureLockView
                 .setOnGestureFinishListener(new OnGestureFinishListener() {
                     @Override
                     public void OnGestureFinish(boolean success, String key) {
                         if (success) {
                             textview.setTextColor(Color.parseColor("#FFFFFF"));
                             textview.setVisibility(View.VISIBLE);
                             textview.setText("密码正确！");
                             textview.startAnimation(animation);
                         } else {
                             textview.setTextColor(Color.parseColor("#FF2525"));
                             textview.setVisibility(View.VISIBLE);
                             textview.setText("密码错误！");
                             textview.startAnimation(animation);
                         }
                     }
                 });
     }
 }