Android自定义UI手势密码简单版

package com.example.imagelock; 
 
import com.example.view.NinePointLineView; 
 
import android.os.bundle; 
import android.app.Activity; 
import android.view.Menu; 
import android.view.View; 
 
public class ImageLockActivity extends Activity { 
 
  @Override 
  public void onCreate(Bundle savedInstanceStatE) { 
    super.onCreate(savedInstanceStatE); 
    View v = new NinePointLineView(this); 
    setContentView(v); 
  } 
} 

package com.example.view; 
 
import com.example.imagelock.R; 
 
import android.content.Context; 
import android.graphics.bitmap; 
import android.graphics.bitmapFactory; 
import android.graphics.Canvas; 
import android.graphics.Color; 
import android.graphics.Paint; 
import android.graphics.Paint.Cap; 
import android.graphics.Typeface; 
import android.util.AttributeSet; 
import android.view.MotionEvent; 
import android.view.View; 
import android.widget.Toast; 
 
public class NinePointLineView extends View { 
 
  /** 
   * 定义3个Paint,还有一个坐标圆点图片 
   */ 
  Paint linePaint = new Paint(); 
  Paint whiteLinePaint = new Paint(); 
  Paint textPaint = new Paint(); 
  Bitmap defaultBitmap = BitmapFactory.decoderesource(getresources(),R.drawable.lock); 
   
  PoinTinfo[] points = new PoinTinfo[9]; 
  int width,height; 
  //坐标点的半径长度 
  int defaultBitmapRadius = defaultBitmap.getWidth() / 2; 
 
  //绘制密码时候出现的原点的直径，半径 
  Bitmap SELEctedBitmap = BitmapFactory.decoderesource(getresources(),R.drawable.inDicator_lock_area); 
  int SELEctedBitmapDiameter = SELEctedBitmap.getWidth(); 
  int SELEctedBitmapRadius = SELEctedBitmapDiameter / 2; 
   
  StringBuffer lockString = new StringBuffer(); 
 
  Context context; 
  /** 构造器*********************************************/ 
  public NinePointLineView(Context context) { 
    super(context); 
    this.context = context; 
    this.setBACkgroundColor(Color.WHITE); 
    initPaint(); 
  } 
 
  public NinePointLineView(Context context,AttributeSet attrs) { 
    super(context,attrs); 
    this.context = context; 
    this.setBACkgroundColor(Color.WHITE); 
    initPaint(); 
  } 
  private void initPaint() { 
    //线--包裹9个原点 
    linePaint.setColor(Color.RED); 
    linePaint.setstrokeWidth(defaultBitmap.getWidth()); 
    linePaint.setAntiAlias(true); 
    linePaint.setstrokeCap(Cap.ROUND); 
    //线内--比原点直径少5 
    whiteLinePaint.setColor(Color.GREEN); 
    whiteLinePaint.setstrokeWidth(defaultBitmap.getWidth() - 5); 
    whiteLinePaint.setAntiAlias(true); 
    whiteLinePaint.setstrokeCap(Cap.ROUND); 
    //字体设置 
    textPaint.setTextSize(30); 
    textPaint.setAntiAlias(true); 
    textPaint.setTypeface(Typeface.MONOSPACE); 
  } 
 
  /********************************************************** 
   * 测量 
   */ 
  @Override 
  protected void onMeasure(int widthMeasureSpec,int heightMeasureSpeC) { 
    width = getWidth(); 
    height = getHeight(); 
    if (width != 0 && height != 0) { 
      initPoints(points); 
    } 
    super.onMeasure(widthMeasureSpec,heightMeasureSpec); 
  } 
 
  /** 
   * 初始化原点 
   */ 
  private void initPoints(PoinTinfo[] points) { 
 
    int len = points.length; 
 
    //2个原点的间距 
    int SELEtedSpacing = (width - SELEctedBitmapDiameter * 3) / 4; 
 
    //第1个原点的坐标 
    int SELEtedX = SELEtedSpacing; 
    int SELEtedY = height - width + SELEtedSpacing; 
 
    //第1个原点内部的小圆的坐标 
    int defaultX = SELEtedX + SELEctedBitmapRadius - defaultBitmapRadius; 
    int defaultY = SELEtedY + SELEctedBitmapRadius - defaultBitmapRadius; 
 
    for (int i = 0; i < len; i++) { 
      //第4、7个原点 
      if (i == 3 || i == 6) { 
        SELEtedX = SELEtedSpacing; 
        //第一个原点y坐标+直径+2点间距离 
        SELEtedY += SELEctedBitmapDiameter + SELEtedSpacing; 
 
        defaultX = SELEtedX + SELEctedBitmapRadius 
            - defaultBitmapRadius; 
        //第一个原点y坐标+直径+2点间距离 
        defaultY += SELEctedBitmapDiameter + SELEtedSpacing; 
 
      } 
      points[i] = new PoinTinfo(i,defaultX,defaultY,SELEtedX,SELEtedY); 
 
      //原点坐标xy为直径+2点间距离 
      SELEtedX += SELEctedBitmapDiameter + SELEtedSpacing; 
      defaultX += SELEctedBitmapDiameter + SELEtedSpacing; 
 
    } 
  } 
  /*****************************************************************/ 
  @Override 
  protected void onLayout(Boolean changed,int left,int top,int right,int bottom) { 
    super.onLayout(changed,left,top,right,bottom); 
  } 
 
  privatE int startX = 0,startY = 0; 
  PoinTinfo startPoint = null; 
  @Override 
  protected void onDraw(Canvas canvas) { 
 
    drawNinePoint(canvas); 
 
    super.onDraw(canvas); 
  } 
  /** 
   * 
   * @param canvas 
   */ 
  private void drawNinePoint(Canvas canvas) { 
 
    if (startPoint != null) { 
      drawEachLine(canvas,startPoint); 
    } 
 
    for(PoinTinfo poinTinfo : points) { 
      if (poinTinfo!=null) { 
         
        if (poinTinfo.isSELEcted()) {       
          canvas.drawBitmap(SELEctedBitmap,poinTinfo.getSELEtedX(),poinTinfo.getSELEtedY(),null); 
        } 
        canvas.drawBitmap(defaultBitmap,poinTinfo.getDefaultX(),poinTinfo.getDefaultY(),null); 
      } 
    } 
 
  } 
  private void drawEachLine(Canvas canvas,PoinTinfo point) { 
    if (point.hasNextId()) { 
      int n = point.getNextId(); 
      drawLine(canvas,point.getCenterX(),point.getCenterY(),points[n].getCenterX(),points[n].getCenterY()); 
      drawEachLine(canvas,points[n]); 
    } 
  } 
 
  private void drawLine(Canvas canvas,float startX,float startY,float stopX,float stopY) { 
    canvas.drawLine(startX,startY,stopX,stopY,linePaint); 
    canvas.drawLine(startX,whiteLinePaint); 
  } 
/** 
 * ******************************************************************** 
 */ 
  Boolean isUp = false; 
  int moveX,moveY; 
  @Override 
  public Boolean onTouchEvent(MotionEvent event) { 
 
    Boolean flag = true; 
    //isUp默认是false--绘制是否完毕，此时为true 
    if (isUp) { 
      finishDraw(); 
 
      Toast.makeText(context,"绘制完毕，手指离开，在点击",0).show(); 
      flag = false; 
 
    } else { 
      handlingEvent(event); 
      flag = true; 
      Toast.makeText(context,"手指一旦绘制",0).show(); 
 
    } 
    //是否处理事件 
    return flag; 
  } 
  private void finishDraw() { 
    for (PoinTinfo temp : points) { 
      temp.setSELEcted(false); 
      temp.setNextId(temp.getId()); 
    } 
    lockString.delete(0,lockString.length()); 
    isUp = false; 
    invalidate(); 
  } 
 
  private void handlingEvent(MotionEvent event) { 
    switch (event.getAction()) { 
    case MotionEvent.ACTION_MOVE: 
      moveX = (int) event.getX(); 
      moveY = (int) event.getY(); 
      for (PoinTinfo temp : points) { 
        if (temp.isInMyPlace(moveX,moveY) && temp.isSELEcted()==falsE) { 
          temp.setSELEcted(true); 
          startX = temp.getCenterX(); 
          startY = temp.getCenterY(); 
          int len = lockString.length(); 
          if (len != 0) { 
            int prEID = lockString.charAt(len - 1) - 48; 
            points[prEID].setNextId(temp.getId()); 
          } 
          lockString.append(temp.getId()); 
          break; 
        } 
      } 
      invalidate(); 
      break; 
 
    case MotionEvent.ACTION_DOWN: 
      //获取按下的xy坐标 
      int downX = (int) event.getX(); 
      int downY = (int) event.getY(); 
      for (PoinTinfo temp : points) { 
        //如果符合距离范围内 
        if (temp.isInMyPlace(downX,downY)) { 
          //将其设置为选中状态 
          temp.setSELEcted(true); 
          //将选中的圆点设置为起始位置圆点 
          startPoint = temp; 
          //将其圆心作为起始点 
          startX = temp.getCenterX(); 
          startY = temp.getCenterY(); 
          lockString.append(temp.getId()); 
          break; 
        } 
      } 
      invalidate(); 
      break; 
 
    case MotionEvent.ACTION_UP: 
      startX = startY = moveX = moveY = 0; 
      //绘制完毕 
      isUp = true; 
      invalidate(); 
      break; 
    default: 
      break; 
    } 
  } 
 
 
 
  /** 
   * 原点bean 
   */ 
  private class PoinTinfo { 
    private Boolean SELEcted; 
 
    private int id; 
 
    private int nextId; 
 
    privatE int defaultX; 
 
    privatE int defaultY; 
 
    privatE int SELEtedX; 
 
    privatE int SELEtedY; 
 
    public PoinTinfo(int id,int defaultX,int defaultY,int SELEtedX,int SELEtedY) { 
      this.id = id; 
      this.nextId = id; 
      this.defaultX = defaultX; 
      this.defaultY = defaultY; 
      this.SELEtedX = SELEtedX; 
      this.SELEtedY = SELEtedY; 
    } 
 
    public Boolean isSELEcted() { 
      return SELEcted; 
    } 
 
    public void setSELEcted(Boolean SELEcted) { 
      this.SELEcted = SELEcted; 
    } 
 
    public int getId() { 
      return id; 
    } 
 
    public int getDefaultX() { 
      return defaultX; 
    } 
 
    public int getDefaultY() { 
      return defaultY; 
    } 
 
    public int getSELEtedX() { 
      return SELEtedX; 
    } 
 
    public int getSELEtedY() { 
      return SELEtedY; 
    } 
 
    public int getCenterX() { 
      return SELEtedX + SELEctedBitmapRadius; 
    } 
 
    public int getCenterY() { 
      return SELEtedY + SELEctedBitmapRadius; 
    } 
 
    public Boolean hasNextId() { 
      return nextId != id; 
    } 
 
    public int getNextId() { 
      return nextId; 
    } 
 
    public void setNextId(int nextId) { 
      this.nextId = nextId; 
    } 
 
    /** 
     * 如果某个xy值在某个原点的左右上下范围内，就说明ok 
     */ 
    public Boolean isInMyPlace(int x,int y) { 
      Boolean inX = x > SELEtedX 
          && x < (SELEtedX + SELEctedBitmapDiameter); 
      Boolean inY = y > SELEtedY 
          && y < (SELEtedY + SELEctedBitmapDiameter); 
 
      return (inX && inY); 
    } 
 
  } 
 
}