Android自定义View-手势密码

最新推荐文章于 2021-05-29 04:33:41 发布
最新推荐文章于 2021-05-29 04:33:41 发布
阅读量651 收藏
点赞数
分类专栏： Android自定义view
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013728021/article/details/78274670
版权

代码在公司项目中使用没有问题

绘制时

这里写图片描述

绘制后

这里写图片描述

选中和未选中效果是两张图片，可以自行设置两张图片代替


import android.content.Context;
import android.content.res.TypedArray;
import android.graphics.Bitmap;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.graphics.Paint.Style;
import android.graphics.PorterDuff;
import android.graphics.drawable.Drawable;
import android.util.AttributeSet;
import android.util.DisplayMetrics;
import android.util.Pair;
import android.view.MotionEvent;
import android.view.View;
import android.view.ViewGroup;

import com.gq.android.R;

import java.util.ArrayList;
import java.util.List;

/**
 * <p>
 * Android-Lock9View
 * </p>
 * <p>
 * 九宫格锁屏视图组件，提供一个九宫格手势屏锁视图功能。
 * </p>
 * <p>
 * 手势处理和连线绘制都有组件内部完成，你只需要绑定这个组件并设置手势完成后的回调对象即可。
 * </p>
 * <p>
 * 请使用 setCallBack(CallBack callBack) 函数设置回调对象。
 * </p>
 * <p>
 * 需要注意的是，不论如何设置，组件的高度永远等于宽度。
 * </p>
 *
 * @author TakWolf (<a
 *         href="mailto:takwolf@foxmail.com">takwolf@foxmail.com</a>)
 */
public class Lock9View extends ViewGroup {

    private Paint paint;
    private Bitmap bitmap;
    private Canvas canvas;

    private List<Pair<NodeView, NodeView>> lineList;
    private NodeView currentNode;

    private StringBuilder pwdSb;
    private CallBack callBack;

    private Drawable nodeSrc;
    private Drawable nodeOnSrc;

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

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

    public Lock9View(Context context, AttributeSet attrs, int defStyleAttr) {
        this(context, attrs, defStyleAttr, 0);
    }

    private Lock9View(Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes) {
        super(context, attrs, defStyleAttr); // TODO api 21
        initFromAttributes(attrs, defStyleAttr);
    }

    private void initFromAttributes(AttributeSet attrs, int defStyleAttr) {
        final TypedArray a = getContext().obtainStyledAttributes(attrs, R.styleable.Lock9View, defStyleAttr, 0);

        nodeSrc = a.getDrawable(R.styleable.Lock9View_nodeSrc);
        nodeOnSrc = a.getDrawable(R.styleable.Lock9View_nodeOnSrc);
        int lineColor = Color.argb(0, 0, 0, 0);
        lineColor = a.getColor(R.styleable.Lock9View_lineColor, lineColor);
        float lineWidth = 20.0f;
        lineWidth = a.getDimension(R.styleable.Lock9View_lineWidth, lineWidth);

        a.recycle();

        paint = new Paint(Paint.DITHER_FLAG);
        paint.setStyle(Style.STROKE);
        paint.setStrokeWidth(lineWidth);
        paint.setColor(lineColor);
        paint.setAntiAlias(true);

        DisplayMetrics dm = getResources().getDisplayMetrics(); // bitmap的宽度是屏幕宽度，足够使用
        bitmap = Bitmap.createBitmap(dm.widthPixels, dm.widthPixels, Bitmap.Config.ARGB_8888);
        canvas = new Canvas();
        canvas.setBitmap(bitmap);

        for (int n = 0; n < 9; n++) {
            NodeView node = new NodeView(getContext(), n + 1);
            addView(node);
        }
        lineList = new ArrayList<>();
        pwdSb = new StringBuilder();

        // 清除FLAG，否则 onDraw() 不会调用，原因是 ViewGroup 默认透明背景不需要调用 onDraw()
        setWillNotDraw(false);
    }

    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        setMeasuredDimension(widthMeasureSpec, widthMeasureSpec); // 我们让高度等于宽度
    }

    @Override
    protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
        if (!changed) {
            return;
        }
        int width = right - left;
        int nodeWidth = width / 3;
        int nodePadding = nodeWidth / 6;
        for (int n = 0; n < 9; n++) {
            NodeView node = (NodeView) getChildAt(n);
            int row = n / 3;
            int col = n % 3;
            int l = col * nodeWidth + nodePadding;
            int t = row * nodeWidth + nodePadding;
            int r = col * nodeWidth + nodeWidth - nodePadding;
            int b = row * nodeWidth + nodeWidth - nodePadding;
            node.layout(l, t, r, b);
        }
    }

    @Override
    protected void onDraw(Canvas canvas) {
        canvas.drawBitmap(bitmap, 0, 0, null);
    }

    @Override
    public boolean onTouchEvent(MotionEvent event) {
        switch (event.getAction()) {
            case MotionEvent.ACTION_DOWN:
            case MotionEvent.ACTION_MOVE:
                NodeView nodeAt = getNodeAt(event.getX(), event.getY());
                if (nodeAt == null && currentNode == null) { // 不需要画线，之前没接触点，当前也没接触点
                    return true;
                } else { // 需要画线
                    clearScreenAndDrawList(); // 清除所有图像，如果已有线，则重新绘制
                    if (currentNode == null) { // 第一个点 nodeAt不为null
                        currentNode = nodeAt;
                        if (null!=currentNode){
                            currentNode.setHighLighted(true);
                            pwdSb.append(currentNode.getNum());
                        }
                    } else if (nodeAt == null || nodeAt.isHighLighted()) { // 已经有点了，当前并未碰触新点
                        // 以currentNode中心和当前触摸点开始画线
                        canvas.drawLine(currentNode.getCenterX(), currentNode.getCenterY(), event.getX(), event.getY(), paint);
                    } else { // 移动到新点
                        canvas.drawLine(currentNode.getCenterX(), currentNode.getCenterY(), nodeAt.getCenterX(), nodeAt.getCenterY(), paint);// 画线
                        nodeAt.setHighLighted(true);
                        Pair<NodeView, NodeView> pair = new Pair<NodeView, NodeView>(currentNode, nodeAt);
                        lineList.add(pair);
                        // 赋值当前的node
                        currentNode = nodeAt;
                        pwdSb.append(currentNode.getNum());
                    }
                    // 通知onDraw重绘
                    invalidate();
                }
                return true;
            case MotionEvent.ACTION_UP:
                // 还没有触摸到点
                if (pwdSb.length() <= 0) {
                    return super.onTouchEvent(event);
                }
                // 回调结果
                if (callBack != null) {
                    callBack.onFinish(pwdSb.toString());
                    pwdSb.setLength(0); // 清空
                }
                // 清空保存点的集合
                currentNode = null;
                lineList.clear();
                clearScreenAndDrawList();
                // 清除高亮
                for (int n = 0; n < getChildCount(); n++) {
                    NodeView node = (NodeView) getChildAt(n);
                    node.setHighLighted(false);
                }
                // 通知onDraw重绘
                invalidate();
                return true;
        }
        return super.onTouchEvent(event);
    }

    /**
     * 清掉屏幕上所有的线，然后画出集合里面的线
     */
    private void clearScreenAndDrawList() {
        canvas.drawColor(Color.TRANSPARENT, PorterDuff.Mode.CLEAR);
        for (Pair<NodeView, NodeView> pair : lineList) {
            canvas.drawLine(pair.first.getCenterX(), pair.first.getCenterY(), pair.second.getCenterX(), pair.second.getCenterY(), paint);
        }
    }

    /**
     * 获取Node，返回null表示当前手指在两个Node之间
     */
    private NodeView getNodeAt(float x, float y) {
        for (int n = 0; n < getChildCount(); n++) {
            NodeView node = (NodeView) getChildAt(n);
            if (!(x >= node.getLeft() && x < node.getRight())) {
                continue;
            }
            if (!(y >= node.getTop() && y < node.getBottom())) {
                continue;
            }
            return node;
        }
        return null;
    }

    /**
     * 设置手势结果的回调监听器
     *
     * @param callBack
     */
    public void setCallBack(CallBack callBack) {
        this.callBack = callBack;
    }

    /**
     * 节点描述类
     */
    private class NodeView extends View {

        private int num;
        private boolean highLighted;

        private NodeView(Context context) {
            super(context);
        }

        @SuppressWarnings("deprecation")
        private NodeView(Context context, int num) {
            this(context);
            this.num = num;
            highLighted = false;
            if (nodeSrc == null) {
                setBackgroundResource(0);
            } else {
                setBackgroundDrawable(nodeSrc);
            }
        }

        public boolean isHighLighted() {
            return highLighted;
        }

        @SuppressWarnings("deprecation")
        public void setHighLighted(boolean highLighted) {
            this.highLighted = highLighted;
            if (highLighted) {
                if (nodeOnSrc == null) {
                    setBackgroundResource(0);
                } else {
                    setBackgroundDrawable(nodeOnSrc);
                }
            } else {
                if (nodeSrc == null) {
                    setBackgroundResource(0);
                } else {
                    setBackgroundDrawable(nodeSrc);
                }
            }
        }

        public int getCenterX() {
            return (getLeft() + getRight()) / 2;
        }

        public int getCenterY() {
            return (getTop() + getBottom()) / 2;
        }

        public int getNum() {
            return num;
        }

    }

    /**
     * 结果回调监听器接口
     */
    public interface CallBack {

        void onFinish(String password);

    }

}

LockPatternIndicator 锁屏指示器

就是上面那九个点


import android.content.Context;
import android.graphics.Canvas;
import android.graphics.Paint;
import android.graphics.Paint.Style;
import android.util.AttributeSet;
import android.view.View;

import com.gq.android.R;

import java.util.List;


/**
 * indicator(three rows and three columns)
 * @author Sym
 */
public class LockPatternIndicator extends View {
	
	private int width, height;
	private int cellBoxWidth, cellBoxHeight;
	private int radius;
	private int offset = 2;
	private Paint defaultPaint, selectPaint;
	private IndicatorCell[][] mIndicatorCells = new IndicatorCell[3][3];

	private static final String TAG = "LockPatternIndicator";

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

	public LockPatternIndicator(Context context, AttributeSet attrs) {
		this(context, attrs, 0);
	}
	
	public LockPatternIndicator(Context context, AttributeSet attrs, int defStyleAttr) {
		super(context, attrs, defStyleAttr);
		this.init();
	}
	
	private void init(){
		initRadius();
		initPaint();
		init9IndicatorCells();
	}

	private void initRadius() {
		this.radius = (this.width - offset*2)/4/2;
		this.cellBoxHeight = (this.height - offset*2)/3;
		this.cellBoxWidth = (this.width - offset*2)/3;
	}
	
	private void initPaint() {
		defaultPaint = new Paint();
		defaultPaint.setColor(getResources().getColor(R.color.c999999));
		defaultPaint.setStrokeWidth(3.0f);
		defaultPaint.setStyle(Style.STROKE);
		defaultPaint.setAntiAlias(true);
		
		selectPaint = new Paint();
		selectPaint.setColor(getResources().getColor(R.color.cff3e19));
		selectPaint.setStrokeWidth(3.0f);
		selectPaint.setStyle(Style.FILL);
		selectPaint.setAntiAlias(true);
	}

	/**
	 * initialize nine cells
	 */
	private void init9IndicatorCells(){
		int distance = this.cellBoxWidth + this.cellBoxWidth/2 - this.radius;
		for(int i = 0; i < 3; i++) {
			for (int j = 0; j < 3; j++) {
				mIndicatorCells[i][j] = new IndicatorCell(distance*j + radius + offset, distance*i + radius + offset, 3*i + j + 1);
			}
		}
	}

	/**
	 * set nine indicator cells size
	 */
	private void set9IndicatorCellsSize() {
		int distance = this.cellBoxWidth + this.cellBoxWidth/2 - this.radius;
		for(int i = 0; i < 3; i++) {
			for (int j = 0; j < 3; j++) {
				mIndicatorCells[i][j].setX(distance*j + radius + offset);
				mIndicatorCells[i][j].setY(distance*i + radius + offset);
			}
		}
	}

	/**
	 * set indicator
	 * @param cells
     */
	public void setIndicator(List<Integer> cells) {
		for( int index=0;index<cells.size();index++) {
			for(int i = 0; i < mIndicatorCells.length; i++) {
				for(int j = 0; j < mIndicatorCells[i].length; j++) {
					if (cells.get(index) == mIndicatorCells[i][j].getIndex()) {
						mIndicatorCells[i][j].setStatus(IndicatorCell.STATE_CHECK);
					}
				}
			}
		}
		this.postInvalidate();
	}

	/**
	 * set default indicator
	 */
	public void setDefaultIndicator() {
		for(int i = 0; i < mIndicatorCells.length; i++) {
			for(int j = 0; j < mIndicatorCells[i].length; j++) {
				mIndicatorCells[i][j].setStatus(IndicatorCell.STATE_NORMAL);
			}
		}
		this.postInvalidate();
	}
	
	@Override
	protected void onDraw(Canvas canvas) {
		super.onDraw(canvas);
		drawToCanvas(canvas);
	}

	@Override
	protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
		super.onMeasure(widthMeasureSpec, heightMeasureSpec);
		this.width = getMeasuredWidth();
		this.height = getMeasuredHeight();
		this.initRadius();
		this.set9IndicatorCellsSize();
		this.invalidate();
	}

	/**
	 * draw the view to canvas
	 * @param canvas
     */
	private void drawToCanvas(Canvas canvas) {
		for(int i = 0; i < mIndicatorCells.length; i++) {
			for(int j = 0; j < mIndicatorCells[i].length; j++) {
				if(mIndicatorCells[i][j].getStatus() == IndicatorCell.STATE_NORMAL) {
					canvas.drawCircle(mIndicatorCells[i][j].getX(), mIndicatorCells[i][j].getY(), radius, defaultPaint);
				} else if(mIndicatorCells[i][j].getStatus() == IndicatorCell.STATE_CHECK) {
					canvas.drawCircle(mIndicatorCells[i][j].getX(), mIndicatorCells[i][j].getY(), radius, selectPaint);
				}
			}
		}
	}
	
	public class IndicatorCell {
		private int x;// the center x of circle
		private int y;// the center y of circle
		private int status = 0;//default
		private int index;// the cell value
		
		public static final int STATE_NORMAL = 0;
		public static final int STATE_CHECK = 1;
		
		public IndicatorCell(){}
		
		public IndicatorCell(int x, int y, int index){
			this.x = x;
			this.y = y;
			this.index = index;
		}
		
		public int getX(){
			return this.x;
		}

		public void setX(int x) {
			this.x = x;
		}
		
		public int getY(){
			return this.y;
		}

		public void setY(int y) {
			this.y = y;
		}
		
		public int getStatus(){
			return this.status;
		}
		
		public void setStatus(int status){
			this.status = status;
		}
		
		public int getIndex() {
			return this.index;
		}
		
		public void setIndex(int index) {
			this.index = index;
		}
	}
	
}

布局


<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:background="@color/white">

    <com.gq.android.views.Lock9View
        android:id="@+id/lock_9_view"
        android:layout_width="@dimen/px_524"
        android:layout_height="@dimen/px_524"
        android:layout_centerInParent="true"
        app:lineColor="@color/cff3e19"
        app:lineWidth="@dimen/px_4"
        app:nodeOnSrc="@drawable/huizhi"
        app:nodeSrc="@drawable/chushi"/>

    <TextView
        android:id="@+id/title"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_alignParentTop="true"
        android:layout_centerHorizontal="true"
        android:layout_marginTop="35dp"
        android:text="请输入原手势密码"
        android:textColor="@color/c333333"
        android:textSize="@dimen/text_size_46_px"  />
    <com.gq.android.views.LockPatternIndicator
    android:id="@+id/lpi_indicator"
        android:visibility="gone"
        android:layout_below="@+id/title"
    android:layout_centerHorizontal="true"
    android:layout_marginTop="@dimen/px_20"
    android:layout_width="@dimen/px_90"
    android:layout_height="@dimen/px_90" />



    <ImageView
        android:id="@+id/back"
        android:layout_width="wrap_content"
        android:layout_height="@dimen/px_46"
        android:layout_marginTop="35dp"
        android:paddingLeft="@dimen/px_15"
        android:paddingRight="@dimen/px_15"
        android:layout_marginLeft="@dimen/px_15"
        android:src="@drawable/fanhui_hui"
        />
    <TextView
        android:id="@+id/tip"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_below="@+id/lpi_indicator"
        android:layout_centerHorizontal="true"
        android:layout_marginTop="20dp"
        android:text=""
        android:textColor="@color/cff3e19"
        android:textSize="16sp" />

    <TextView
        android:id="@+id/by_login"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:padding="@dimen/px_10"
        android:text="通过登录密码修改"
        android:textColor="@color/c54adff"
        android:textSize="16sp"
        android:layout_alignBaseline="@+id/forget_pwd"
        android:layout_alignBottom="@+id/forget_pwd"
        android:layout_alignLeft="@+id/lock_9_view"
        android:layout_alignStart="@+id/lock_9_view" />

    <TextView
        android:id="@+id/forget_pwd"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_marginBottom="36dp"
        android:padding="@dimen/px_10"
        android:text="忘记登录密码"
        android:textColor="@color/c54adff"
        android:textSize="16sp"
        android:layout_alignParentBottom="true"
        android:layout_alignRight="@+id/lock_9_view"
        android:layout_alignEnd="@+id/lock_9_view" />

</RelativeLayout>

java使用


  lock9View.setCallBack(new CallBack() {
            @Override
            public void onFinish(String password) {
		          //绘制完成后指示器显示
		          //重置
                  lpi_indicator.setDefaultIndicator();
                  //画轨迹
                if(!TextUtils.isEmpty(password)){
                    List<Integer> ints=new ArrayList<Integer>();
                    for(int i=0;i<password.length();i++){
                        ints.add(Integer.valueOf(password.substring(i,i+1)));
                    }
                    lpi_indicator.setIndicator(ints);
                }
            }
        });
奋斗的bigHead
关注
专栏目录
Android 自定义控件实现手势密码
HyperionChen
02-16 2705
国际惯例：放上效果图（求人气啊，每次文章都石沉大海）      首先呢想写这个手势密码的想法呢，完全是凭空而来的，然后笔者就花了一天时间弄出来了。本以为这个东西很简单，实际上手的时候发现，还有很多逻辑需要处理，稍不注意就容易乱套。写个UI效果图大约只花了3个小时，但是处理逻辑就处理了2个小时！废话不多说，下面开始讲解。     楼主呢，自己比较自定义控件，什么东西都掌握在自己的手里
Android自定义view---手势识别，双击，惯性滑动，相册图片效果
lbj23vs6的博客
10-04 1309
文章目录前言一、GestureDetectorCompat是什么？二、使用步骤1.定义一个GestureDetectorCompat的实例2.重写方法，实现自定义效果①想让检测器消费一系列的触摸事件，那么就要在重写方法`onDown`中去返回true，那么后续的一系列触摸过程才能让手势检测器获取②既然我们要去实现双击效果，那么就得再给手势检测器设置一个监听③实现双击变大变小④重写onDoubleTap④实现惯性滑动总结完整代码 前言 在view中我们可以重写onTouchEvent来自定义点击事件，但是M
android 自定义view 手势,android自定义View实现手势解锁
weixin_42443992的博客
05-25 365
有时候为了程序的安全性,我们经常要采取一些安全措施,就像我们常用的支付宝那样,隔一定的时间再回到应用程序时会让用户利用手势去解锁应用程序,最近由于项目需求,也要求做这样一个功能,当用户切出本应用程序15分钟后回来,让用户手势解锁,整个需求的难点就在如何实现这个手势锁,开始一点头绪也没有,没有一点思路去实现这个手势解锁功能,在google了一番后看了一篇非常好的博客后,按照博主的思路的确是可以实现一...
Android 自定义 View——手势密码
Young_Time的博客
06-29 614
    Android 自定义 View 当然是十分重要的，笔者这两天写了一个自定义 View 的手势密码，和大家分享分享：    首先，我们来创建一个表示点的类，Point.java：public class Point { // 点的三种状态 public static final int POINT_STATUS_NORMAL = 0; public static ...
android自定义控件手势密码
kieCool的博客
09-20 845
现在很多app都用到一种安全机制，手势密码，特别是银行相关的app，虽然他也并不是那么安全，但是就是喜欢用。今天来看一个简单而炫酷的手势密码锁，废话不多说，上图上代码。看图说话，想怎么定义就怎么定义，使用起来就是这么任性。。。
Android自定义view-电子签名画板
01-20
在Android开发中，自定义View是一种常见的需求，用于实现特定的功能或界面效果。在这个场景中，我们关注的是一个自定义的电子签名画板——`ElecSignatureView`。这个类继承自`View`，用于创建一个用户可以在上面进行...
Android-安卓手势解锁示例-手势解锁-自定义手势-安卓手势
08-13
本示例主要关注如何在Android应用中实现手势解锁功能，包括基础的手势解锁逻辑以及自定义手势识别。 一、手势解锁基本原理 手势解锁的核心在于识别用户在触屏上绘制的连续点序列。系统记录用户设定的手势路径（一...
Android自定义View-手势检测(GestureDetector)
qq_34341338的博客
02-27 967
Google为了方便我们进行手势检测，早就封装了相关的内容提供我们使用。即Android手势检测，主要就是对GestureDetector类的使用和说明。 1.GestureDetector GestureDetector可以使用MotionEvents检测各种手势和事件。其内部包含四个监听器(三个接口以及一个外部类)： 接口 含义 OnGestureListener 手势检测：包...
Android手势密码view笔记（二）
vv_bug
02-28 2017
我们还是接着我们上一篇博客中的内容往下讲哈，上一节 Android手势密码view笔记（一）我们已经实现了我们的IndicatorView指示器view了：下面我们来实现下我们的手势密码view：实现思路：1、我们照样需要拿到用户需要显示的一些属性（行、列、选中的图片、未选中的图片、错误显示的图片、连接线的宽度跟颜色......）。2、我们需要根据手势的变换然后需要判断当前手指位置是不是在某个点中，
Android自定义View实现随手势滑动控件
08-31
主要为大家详细介绍了Android自定义View实现随手势滑动的控件，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
Android自定义View九宫格手势密码解锁
01-05
由于公司新的项目需要用到九宫格手势密码解锁的功能，于是觉得自己写一个。废话不多说，直接上效果图： 首选我们来分析下实现的思路： 1. 绘制出相对于这个View的居中的九个点，作为默认状态的点 2. 点击屏幕的时候是否点击在这九个点上 3. 在屏幕上滑动的时候，绘制两个点之间的线条，以及选中状态的点 4. 手指离开屏幕的时候判断手势密码是否正确，如若错误这把错误状态下的点和线绘制出来。 具体实现： 首先我们得绘制出默认正常状态下的九个点： /** * 点的bean * Created by Administrator on 2015/9/21. */ public
PasswordLock:android数字锁UI
05-17
PasswordLock android数字锁UI 九宫格密码锁 这两个不是完整的锁屏应用，只是锁屏应用的解锁界面的自定义控件
android简单登录自定义密码,Android自定义UI手势密码简单版
weixin_35695434的博客
05-27 164
先看看效果图：ImageLockActivitypackage com.example.imagelock;import com.example.view.NinePointLineView;import android.os.Bundle;import android.app.Activity;import android.view.Menu;import android.view.View;p...
android 自定义密码输入,Android自定义View之密码输入框
weixin_29251567的博客
05-25 380
本文为Android自定义View系列，难度不大，都是些坐标的计算，阅读本文大概需要5分钟。Demo效果图分析宽高计算各个变量含义privateintpasswordLength;//密码个数privatelongcursorFlashTime;//光标闪动间隔时间privateintpasswordPadding;//每个密码间的间隔privateintpasswordSize...
自定义View之--九宫格图形密码锁
Demi的博客
04-14 2900
前言：很多金融和几大商业银行的APP,都使用了九宫格图形密码锁来增强资金账户的安全。我也是金融公司的一员，在空余的时候，写下这个view，可以说是明智之举。效果预览这样一个逻辑差不多可以满足基本的需求了。接下来就看代码咯。NineSquareView的成长1、重写构造方法和初始化属性 private Paint pointPaint; //画点的画笔 private Paint li
android 手势密码存储,Android 简易手势密码开源库详解
weixin_34378126的博客
05-27 442
简介本文介绍一个Android手势密码开源库的使用及实现的详细过程，该开源库主要实现以下几个功能：支持手势密码的绘制，并支持密码保存功能，解锁时自动比对密码给出结果封装了绘制密码的方法，比对两次密码是否一致，可以快捷地进行手势密码的设置可以设置密码输入错误后的重试次数上限可以自定义不同状态下手势密码图案的颜色可以自定义手势密码的触摸点数量(n*n)最近需要用到手势密码解锁功能，找了一些demo感觉...
android 自定义锁屏api,Android自定义view 锁屏的绘制
weixin_30989967的博客
05-29 278
1. 锁屏效果如下图所示2. 源码及流程介绍2.1 辅助线绘制canvas.drawLine(0, standardY, canvas.getWidth(), standardY, paint);paint.setColor(Color.BLUE);canvas.drawLine(standardX, 0, standardX, canvas.getHeight(), paint);2.2 绘制忽...
Android自定义View实现手势密码教程
自定义Android View手势密码是一个涉及用户界面设计、事件处理、数据结构管理以及可能的加密算法应用的综合项目。通过理解和实践这个过程，开发者能够加深对Android框架的理解，同时掌握如何创造具有吸引力和功能性...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值