Simple version of Android custom UI gesture password

Take a look at the effect diagram:

ImageLockActivity

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); 
  } 
} 

NinePointLineView

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 { 
  /** 
   * Define3A Paint and a coordinate point image 
   */ 
  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; 
  //The radius length of the coordinate point 
  int defaultBitmapRadius = defaultBitmap.getWidth() / 2; 
  //The diameter of the origin point when drawing the password 
  Bitmap selectedBitmap = BitmapFactory.decodeResource(getResources(), 
      R.drawable.indicator_lock_area); 
  int selectedBitmapDiameter = selectedBitmap.getWidth(); 
  int selectedBitmapRadius = selectedBitmapDiameter / 2; 
  StringBuffer lockString = new StringBuffer(); 
  Context context; 
  /** constructor*********************************************/ 
  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() { 
    //line--enclosed9origin 
    linePaint.setColor(Color.RED); 
    linePaint.setStrokeWidth(defaultBitmap.getWidth()); 
    linePaint.setAntiAlias(true); 
    linePaint.setStrokeCap(Cap.ROUND); 
    //inside the line--less than the diameter of the original point5 
    whiteLinePaint.setColor(Color.GREEN); 
    whiteLinePaint.setStrokeWidth(defaultBitmap.getWidth()) - 5); 
    whiteLinePaint.setAntiAlias(true); 
    whiteLinePaint.setStrokeCap(Cap.ROUND); 
    //font setting 
    textPaint.setTextSize(30); 
    textPaint.setAntiAlias(true); 
    textPaint.setTypeface(Typeface.MONOSPACE); 
  } 
  /********************************************************** 
   * measure 
   */ 
  @Override 
  protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) { 
    width = getWidth(); 
    height = getHeight(); 
    if (width != 0 && height != 0) { 
      initPoints(points); 
    } 
    super.onMeasure(widthMeasureSpec, heightMeasureSpec); 
  } 
  /** 
   * Initialize the origin 
   */ 
  private void initPoints(PointInfo[] points) { 
    int len = points.length; 
    //2spacing between origins 
    int seletedSpacing = (width - selectedBitmapDiameter * 3) / 4; 
    //the1coordinates of the origin 
    int seletedX = seletedSpacing; 
    int seletedY = height - width + seletedSpacing; 
    //the1coordinates of the small circle inside the origin 
    int defaultX = seletedX + selectedBitmapRadius - defaultBitmapRadius; 
    int defaultY = seletedY + selectedBitmapRadius - defaultBitmapRadius; 
    for (int i = 0; i < len; i++) { 
      //the4,7origin 
      if (i == 3 || i == 6) { 
        seletedX = seletedSpacing; 
        //The y-coordinate of the first origin+diameter+2The distance between points 
        seletedY += selectedBitmapDiameter + seletedSpacing; 
        defaultX = seletedX + selectedBitmapRadius 
            - defaultBitmapRadius; 
        //The y-coordinate of the first origin+diameter+2The distance between points 
        defaultY += selectedBitmapDiameter + seletedSpacing; 
      } 
      points[i] = new PointInfo(i, defaultX, defaultY, seletedX, seletedY); 
      //The origin coordinates xy are the diameter+2The distance between points 
      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, startY, stopX, stopY, whiteLinePaint); 
  } 
/** 
 * ******************************************************************** 
 */ 
  boolean isUp = false; 
  int moveX, moveY; 
  @Override 
  public boolean onTouchEvent(MotionEvent event) { 
    boolean flag = true; 
    //isUp is default false--Whether the drawing is complete, it is true at this moment 
    if (isUp) { 
      finishDraw(); 
      Toast.makeText(context, "Drawing is complete, finger left, click", 0).show(); 
      flag = false; 
    } else { 
      handlingEvent(event); 
      flag = true; 
      Toast.makeText(context, "Once the finger is drawn", 0).show(); 
    } 
    //Whether to handle the event 
    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: 
      //Obtain the pressed xy coordinates 
      int downX = (int) event.getX(); 
      int downY = (int) event.getY(); 
      for (PointInfo temp : points) { 
        //If it is within the distance range 
        if (temp.isInMyPlace(downX, downY)) { 
          //Set it to selected state 
          temp.setSelected(true); 
          //Set the selected circle point as the starting point 
          startPoint = temp; 
          //Take the center as the starting point 
          startX = temp.getCenterX(); 
          startY = temp.getCenterY(); 
          lockString.append(temp.getId()); 
          break; 
        } 
      } 
      invalidate(); 
      break; 
    case MotionEvent.ACTION_UP: 
      startX = startY = moveX = moveY = 0; 
      //Drawing completed 
      isUp = true; 
      invalidate(); 
      break; 
    default: 
      break; 
    } 
  } 
  /** 
   * Origin 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; 
    } 
    /** 
     * If a certain xy value is within the left and right, up and down range of a certain origin, it means 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); 
    } 
  } 
} 

That's all for this article. I hope it will be helpful to everyone's learning and that everyone will support the Yelling Tutorial more.

Declaration: The content of this article is from the Internet, and the copyright belongs to the original author. The content is contributed and uploaded by Internet users spontaneously. This website does not own the copyright, has not been manually edited, and does not assume any relevant legal liability. If you find any content suspected of copyright infringement, please send an email to: notice#oldtoolbag.com (Please replace # with @ when sending an email to report, and provide relevant evidence. Once verified, this site will immediately delete the content suspected of infringement.)