超实用的Android手势锁制作实例教程

今天偶遇以github上gesturelock关于手势锁的一个例子(有兴趣的去搜索下看看),于是下载下来研究,无奈基本没有注释,代码上存在一些问题(当设置gravity=center_vertical无法进行手势选择,无意中发现的),于是借鉴这位仁兄的代码,自己重写写了一个,修复了一些问题,加入一些基本的自定义属性,在此先感谢这位兄弟~。
先上图,默认效果图:

当然可以自定义数量啊,颜色神马的,自定义效果图:

如果你有艺术细胞,可以给我推荐几个颜色,无奈个人审美有问题~

1、整体思路
a、自定义了一个RelativeLayout(GestureLockViewGroup)在里面会根据传入的每行的个数,生成多个GestureLockView(就是上面一个个小圈圈),然后会自动进行布局,里面的宽度,间距,内圆的直径,箭头的大小神马的都是百分比实现的,所以大胆的设置你喜欢的个数,只要你没有密集恐惧症~
b、GestureLockView有三个状态,没有手指触碰、手指触碰、和手指抬起,会根据这三个状态绘制不同的效果,以及抬起时的小箭头需要旋转的角度,会根据用户选择的GestureLockView,进行计算,在GestureLockViewGroup为每个GestureLockView设置
c、GestureLockViewGroup主要就是判断用户ACTION_MOVE,ACTION_DOWN , ACTION_UP时改变选中的GestureLockView的状态,并且记录下来,提供一定的回调。
下面开始看代码:

2、声明一些用户可以设置的属性:

<?xml version="1.0" encoding="utf-8"?>
<resources> 

  <attr name="color_no_finger_inner_circle" format="color" />
  <attr name="color_no_finger_outer_circle" format="color" />
  <attr name="color_finger_on" format="color" />
  <attr name="color_finger_up" format="color" />
  <attr name="count" format="integer" />
  <attr name="tryTimes" format="integer" /> 

  <declare-styleable name="GestureLockViewGroup">
    <attr name="color_no_finger_inner_circle" />
    <attr name="color_no_finger_outer_circle" />
    <attr name="color_finger_on" />
    <attr name="color_finger_up" />
    <attr name="count" />
    <attr name="tryTimes" />
  </declare-styleable> 

</resources>

用户可以用过在xml文件中设置这些属性,改变外观,最多尝试次数以及数量等。

3、GestureLockView

package com.zhy.zhy_gesturelockview.view; 

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

public class GestureLockView extends View
{
  private static final String TAG = "GestureLockView";
  /**
   * GestureLockView的三种状态
   */
  enum Mode
  {
    STATUS_NO_FINGER, STATUS_FINGER_ON, STATUS_FINGER_UP;
  } 

  /**
   * GestureLockView的当前状态
   */
  private Mode mCurrentStatus = Mode.STATUS_NO_FINGER; 

  /**
   * 宽度
   */
  private int mWidth;
  /**
   * 高度
   */
  private int mHeight;
  /**
   * 外圆半径
   */
  private int mRadius;
  /**
   * 画笔的宽度
   */
  private int mStrokeWidth = 2; 

  /**
   * 圆心坐标
   */
  private int mCenterX;
  private int mCenterY;
  private Paint mPaint; 

  /**
   * 箭头(小三角最长边的一半长度 = mArrawRate * mWidth / 2 )
   */
  private float mArrowRate = 0.333f;
  private int mArrowDegree = -1;
  private Path mArrowPath;
  /**
   * 内圆的半径 = mInnerCircleRadiusRate * mRadus
   *
   */
  private float mInnerCircleRadiusRate = 0.3F; 

  /**
   * 四个颜色,可由用户自定义,初始化时由GestureLockViewGroup传入
   */
  private int mColorNoFingerInner;
  private int mColorNoFingerOutter;
  private int mColorFingerOn;
  private int mColorFingerUp; 

  public GestureLockView(Context context , int colorNoFingerInner , int colorNoFingerOutter , int colorFingerOn , int colorFingerUp )
  {
    super(context);
    this.mColorNoFingerInner = colorNoFingerInner;
    this.mColorNoFingerOutter = colorNoFingerOutter;
    this.mColorFingerOn = colorFingerOn;
    this.mColorFingerUp = colorFingerUp;
    mPaint = new Paint(Paint.ANTI_ALIAS_FLAG);
    mArrowPath = new Path(); 

  } 

  @Override
  protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec)
  {
    super.onMeasure(widthMeasureSpec, heightMeasureSpec); 

    mWidth = MeasureSpec.getSize(widthMeasureSpec);
    mHeight = MeasureSpec.getSize(heightMeasureSpec); 

    // 取长和宽中的小值
    mWidth = mWidth < mHeight ? mWidth : mHeight;
    mRadius = mCenterX = mCenterY = mWidth / 2;
    mRadius -= mStrokeWidth / 2; 

    // 绘制三角形,初始时是个默认箭头朝上的一个等腰三角形,用户绘制结束后,根据由两个GestureLockView决定需要旋转多少度
    float mArrowLength = mWidth / 2 * mArrowRate;
    mArrowPath.moveTo(mWidth / 2, mStrokeWidth + 2);
    mArrowPath.lineTo(mWidth / 2 - mArrowLength, mStrokeWidth + 2
        + mArrowLength);
    mArrowPath.lineTo(mWidth / 2 + mArrowLength, mStrokeWidth + 2
        + mArrowLength);
    mArrowPath.close();
    mArrowPath.setFillType(Path.FillType.WINDING); 

  } 

  @Override
  protected void onDraw(Canvas canvas)
  { 

    switch (mCurrentStatus)
    {
    case STATUS_FINGER_ON: 

      // 绘制外圆
      mPaint.setStyle(Style.STROKE);
      mPaint.setColor(mColorFingerOn);
      mPaint.setStrokeWidth(2);
      canvas.drawCircle(mCenterX, mCenterY, mRadius, mPaint);
      // 绘制内圆
      mPaint.setStyle(Style.FILL);
      canvas.drawCircle(mCenterX, mCenterY, mRadius
          * mInnerCircleRadiusRate, mPaint);
      break;
    case STATUS_FINGER_UP:
      // 绘制外圆
      mPaint.setColor(mColorFingerUp);
      mPaint.setStyle(Style.STROKE);
      mPaint.setStrokeWidth(2);
      canvas.drawCircle(mCenterX, mCenterY, mRadius, mPaint);
      // 绘制内圆
      mPaint.setStyle(Style.FILL);
      canvas.drawCircle(mCenterX, mCenterY, mRadius
          * mInnerCircleRadiusRate, mPaint); 

      drawArrow(canvas); 

      break; 

    case STATUS_NO_FINGER: 

      // 绘制外圆
      mPaint.setStyle(Style.FILL);
      mPaint.setColor(mColorNoFingerOutter);
      canvas.drawCircle(mCenterX, mCenterY, mRadius, mPaint);
      // 绘制内圆
      mPaint.setColor(mColorNoFingerInner);
      canvas.drawCircle(mCenterX, mCenterY, mRadius
          * mInnerCircleRadiusRate, mPaint);
      break; 

    } 

  } 

  /**
   * 绘制箭头
   * @param canvas
   */
  private void drawArrow(Canvas canvas)
  {
    if (mArrowDegree != -1)
    {
      mPaint.setStyle(Paint.Style.FILL); 

      canvas.save();
      canvas.rotate(mArrowDegree, mCenterX, mCenterY);
      canvas.drawPath(mArrowPath, mPaint); 

      canvas.restore();
    } 

  } 

  /**
   * 设置当前模式并重绘界面
   *
   * @param mode
   */
  public void setMode(Mode mode)
  {
    this.mCurrentStatus = mode;
    invalidate();
  } 

  public void setArrowDegree(int degree)
  {
    this.mArrowDegree = degree;
  } 

  public int getArrowDegree()
  {
    return this.mArrowDegree;
  }
}

注释很详细,主要就是onDraw时,判断当前状态,绘制不同的显示效果;状态的改变都是GestureLockViewGroup的onTouchEvent中设置的。

4、GestureLockViewGroup

package com.zhy.zhy_gesturelockview.view; 

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

import android.content.Context;
import android.content.res.TypedArray;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.graphics.Path;
import android.graphics.Point;
import android.util.AttributeSet;
import android.util.Log;
import android.view.MotionEvent;
import android.view.View;
import android.widget.RelativeLayout; 

import com.zhy.zhy_gesturelockview.R;
import com.zhy.zhy_gesturelockview.view.GestureLockView.Mode; 

/**
 * 整体包含n*n个GestureLockView,每个GestureLockView间间隔mMarginBetweenLockView,
 * 最外层的GestureLockView与容器存在mMarginBetweenLockView的外边距
 *
 * 关于GestureLockView的边长(n*n): n * mGestureLockViewWidth + ( n + 1 ) *
 * mMarginBetweenLockView = mWidth ; 得:mGestureLockViewWidth = 4 * mWidth / ( 5
 * * mCount + 1 ) 注:mMarginBetweenLockView = mGestureLockViewWidth * 0.25 ;
 *
 * @author zhy
 *
 */
public class GestureLockViewGroup extends RelativeLayout
{ 

  private static final String TAG = "GestureLockViewGroup";
  /**
   * 保存所有的GestureLockView
   */
  private GestureLockView[] mGestureLockViews;
  /**
   * 每个边上的GestureLockView的个数
   */
  private int mCount = 4;
  /**
   * 存储答案
   */
  private int[] mAnswer = { 0, 1, 2, 5, 8 };
  /**
   * 保存用户选中的GestureLockView的id
   */
  private List<Integer> mChoose = new ArrayList<Integer>(); 

  private Paint mPaint;
  /**
   * 每个GestureLockView中间的间距 设置为:mGestureLockViewWidth * 25%
   */
  private int mMarginBetweenLockView = 30;
  /**
   * GestureLockView的边长 4 * mWidth / ( 5 * mCount + 1 )
   */
  private int mGestureLockViewWidth; 

  /**
   * GestureLockView无手指触摸的状态下内圆的颜色
   */
  private int mNoFingerInnerCircleColor = 0xFF939090;
  /**
   * GestureLockView无手指触摸的状态下外圆的颜色
   */
  private int mNoFingerOuterCircleColor = 0xFFE0DBDB;
  /**
   * GestureLockView手指触摸的状态下内圆和外圆的颜色
   */
  private int mFingerOnColor = 0xFF378FC9;
  /**
   * GestureLockView手指抬起的状态下内圆和外圆的颜色
   */
  private int mFingerUpColor = 0xFFFF0000; 

  /**
   * 宽度
   */
  private int mWidth;
  /**
   * 高度
   */
  private int mHeight; 

  private Path mPath;
  /**
   * 指引线的开始位置x
   */
  private int mLastPathX;
  /**
   * 指引线的开始位置y
   */
  private int mLastPathY;
  /**
   * 指引下的结束位置
   */
  private Point mTmpTarget = new Point(); 

  /**
   * 最大尝试次数
   */
  private int mTryTimes = 4;
  /**
   * 回调接口
   */
  private OnGestureLockViewListener mOnGestureLockViewListener; 

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

  public GestureLockViewGroup(Context context, AttributeSet attrs,
      int defStyle)
  {
    super(context, attrs, defStyle);
    /**
     * 获得所有自定义的参数的值
     */
    TypedArray a = context.getTheme().obtainStyledAttributes(attrs,
        R.styleable.GestureLockViewGroup, defStyle, 0);
    int n = a.getIndexCount(); 

    for (int i = 0; i < n; i++)
    {
      int attr = a.getIndex(i);
      switch (attr)
      {
      case R.styleable.GestureLockViewGroup_color_no_finger_inner_circle:
        mNoFingerInnerCircleColor = a.getColor(attr,
            mNoFingerInnerCircleColor);
        break;
      case R.styleable.GestureLockViewGroup_color_no_finger_outer_circle:
        mNoFingerOuterCircleColor = a.getColor(attr,
            mNoFingerOuterCircleColor);
        break;
      case R.styleable.GestureLockViewGroup_color_finger_on:
        mFingerOnColor = a.getColor(attr, mFingerOnColor);
        break;
      case R.styleable.GestureLockViewGroup_color_finger_up:
        mFingerUpColor = a.getColor(attr, mFingerUpColor);
        break;
      case R.styleable.GestureLockViewGroup_count:
        mCount = a.getInt(attr, 3);
        break;
      case R.styleable.GestureLockViewGroup_tryTimes:
        mTryTimes = a.getInt(attr, 5);
      default:
        break;
      }
    } 

    a.recycle(); 

    // 初始化画笔
    mPaint = new Paint(Paint.ANTI_ALIAS_FLAG);
    mPaint.setStyle(Paint.Style.STROKE);
    // mPaint.setStrokeWidth(20);
    mPaint.setStrokeCap(Paint.Cap.ROUND);
    mPaint.setStrokeJoin(Paint.Join.ROUND);
    // mPaint.setColor(Color.parseColor("#aaffffff"));
    mPath = new Path();
  } 

  @Override
  protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec)
  {
    super.onMeasure(widthMeasureSpec, heightMeasureSpec); 

    mWidth = MeasureSpec.getSize(widthMeasureSpec);
    mHeight = MeasureSpec.getSize(heightMeasureSpec); 

    // Log.e(TAG, mWidth + "");
    // Log.e(TAG, mHeight + ""); 

    mHeight = mWidth = mWidth < mHeight ? mWidth : mHeight; 

    // setMeasuredDimension(mWidth, mHeight); 

    // 初始化mGestureLockViews
    if (mGestureLockViews == null)
    {
      mGestureLockViews = new GestureLockView[mCount * mCount];
      // 计算每个GestureLockView的宽度
      mGestureLockViewWidth = (int) (4 * mWidth * 1.0f / (5 * mCount + 1));
      //计算每个GestureLockView的间距
      mMarginBetweenLockView = (int) (mGestureLockViewWidth * 0.25);
      // 设置画笔的宽度为GestureLockView的内圆直径稍微小点(不喜欢的话,随便设)
      mPaint.setStrokeWidth(mGestureLockViewWidth * 0.29f); 

      for (int i = 0; i < mGestureLockViews.length; i++)
      {
        //初始化每个GestureLockView
        mGestureLockViews[i] = new GestureLockView(getContext(),
            mNoFingerInnerCircleColor, mNoFingerOuterCircleColor,
            mFingerOnColor, mFingerUpColor);
        mGestureLockViews[i].setId(i + 1);
        //设置参数,主要是定位GestureLockView间的位置
        RelativeLayout.LayoutParams lockerParams = new RelativeLayout.LayoutParams(
            mGestureLockViewWidth, mGestureLockViewWidth); 

        // 不是每行的第一个,则设置位置为前一个的右边
        if (i % mCount != 0)
        {
          lockerParams.addRule(RelativeLayout.RIGHT_OF,
              mGestureLockViews[i - 1].getId());
        }
        // 从第二行开始,设置为上一行同一位置View的下面
        if (i > mCount - 1)
        {
          lockerParams.addRule(RelativeLayout.BELOW,
              mGestureLockViews[i - mCount].getId());
        }
        //设置右下左上的边距
        int rightMargin = mMarginBetweenLockView;
        int bottomMargin = mMarginBetweenLockView;
        int leftMagin = 0;
        int topMargin = 0;
        /**
         * 每个View都有右外边距和底外边距 第一行的有上外边距 第一列的有左外边距
         */
        if (i >= 0 && i < mCount)// 第一行
        {
          topMargin = mMarginBetweenLockView;
        }
        if (i % mCount == 0)// 第一列
        {
          leftMagin = mMarginBetweenLockView;
        } 

        lockerParams.setMargins(leftMagin, topMargin, rightMargin,
            bottomMargin);
        mGestureLockViews[i].setMode(Mode.STATUS_NO_FINGER);
        addView(mGestureLockViews[i], lockerParams);
      } 

      Log.e(TAG, "mWidth = " + mWidth + " , mGestureViewWidth = "
          + mGestureLockViewWidth + " , mMarginBetweenLockView = "
          + mMarginBetweenLockView); 

    }
  } 

  @Override
  public boolean onTouchEvent(MotionEvent event)
  {
    int action = event.getAction();
    int x = (int) event.getX();
    int y = (int) event.getY(); 

    switch (action)
    {
    case MotionEvent.ACTION_DOWN:
      // 重置
      reset();
      break;
    case MotionEvent.ACTION_MOVE:
      mPaint.setColor(mFingerOnColor);
      mPaint.setAlpha(50);
      GestureLockView child = getChildIdByPos(x, y);
      if (child != null)
      {
        int cId = child.getId();
        if (!mChoose.contains(cId))
        {
          mChoose.add(cId);
          child.setMode(Mode.STATUS_FINGER_ON);
          if (mOnGestureLockViewListener != null)
            mOnGestureLockViewListener.onBlockSelected(cId);
          // 设置指引线的起点
          mLastPathX = child.getLeft() / 2 + child.getRight() / 2;
          mLastPathY = child.getTop() / 2 + child.getBottom() / 2; 

          if (mChoose.size() == 1)// 当前添加为第一个
          {
            mPath.moveTo(mLastPathX, mLastPathY);
          } else
          // 非第一个,将两者使用线连上
          {
            mPath.lineTo(mLastPathX, mLastPathY);
          } 

        }
      }
      // 指引线的终点
      mTmpTarget.x = x;
      mTmpTarget.y = y;
      break;
    case MotionEvent.ACTION_UP: 

      mPaint.setColor(mFingerUpColor);
      mPaint.setAlpha(50);
      this.mTryTimes--; 

      // 回调是否成功
      if (mOnGestureLockViewListener != null && mChoose.size() > 0)
      {
        mOnGestureLockViewListener.onGestureEvent(checkAnswer());
        if (this.mTryTimes == 0)
        {
          mOnGestureLockViewListener.onUnmatchedExceedBoundary();
        }
      } 

      Log.e(TAG, "mUnMatchExceedBoundary = " + mTryTimes);
      Log.e(TAG, "mChoose = " + mChoose);
      // 将终点设置位置为起点,即取消指引线
      mTmpTarget.x = mLastPathX;
      mTmpTarget.y = mLastPathY; 

      // 改变子元素的状态为UP
      changeItemMode(); 

      // 计算每个元素中箭头需要旋转的角度
      for (int i = 0; i + 1 < mChoose.size(); i++)
      {
        int childId = mChoose.get(i);
        int nextChildId = mChoose.get(i + 1); 

        GestureLockView startChild = (GestureLockView) findViewById(childId);
        GestureLockView nextChild = (GestureLockView) findViewById(nextChildId); 

        int dx = nextChild.getLeft() - startChild.getLeft();
        int dy = nextChild.getTop() - startChild.getTop();
        // 计算角度
        int angle = (int) Math.toDegrees(Math.atan2(dy, dx)) + 90;
        startChild.setArrowDegree(angle);
      }
      break; 

    }
    invalidate();
    return true;
  } 

  private void changeItemMode()
  {
    for (GestureLockView gestureLockView : mGestureLockViews)
    {
      if (mChoose.contains(gestureLockView.getId()))
      {
        gestureLockView.setMode(Mode.STATUS_FINGER_UP);
      }
    }
  } 

  /**
   *
   * 做一些必要的重置
   */
  private void reset()
  {
    mChoose.clear();
    mPath.reset();
    for (GestureLockView gestureLockView : mGestureLockViews)
    {
      gestureLockView.setMode(Mode.STATUS_NO_FINGER);
      gestureLockView.setArrowDegree(-1);
    }
  }
  /**
   * 检查用户绘制的手势是否正确
   * @return
   */
  private boolean checkAnswer()
  {
    if (mAnswer.length != mChoose.size())
      return false; 

    for (int i = 0; i < mAnswer.length; i++)
    {
      if (mAnswer[i] != mChoose.get(i))
        return false;
    } 

    return true;
  } 

  /**
   * 检查当前左边是否在child中
   * @param child
   * @param x
   * @param y
   * @return
   */
  private boolean checkPositionInChild(View child, int x, int y)
  { 

    //设置了内边距,即x,y必须落入下GestureLockView的内部中间的小区域中,可以通过调整padding使得x,y落入范围不变大,或者不设置padding
    int padding = (int) (mGestureLockViewWidth * 0.15); 

    if (x >= child.getLeft() + padding && x <= child.getRight() - padding
        && y >= child.getTop() + padding
        && y <= child.getBottom() - padding)
    {
      return true;
    }
    return false;
  } 

  /**
   * 通过x,y获得落入的GestureLockView
   * @param x
   * @param y
   * @return
   */
  private GestureLockView getChildIdByPos(int x, int y)
  {
    for (GestureLockView gestureLockView : mGestureLockViews)
    {
      if (checkPositionInChild(gestureLockView, x, y))
      {
        return gestureLockView;
      }
    } 

    return null; 

  } 

  /**
   * 设置回调接口
   *
   * @param listener
   */
  public void setOnGestureLockViewListener(OnGestureLockViewListener listener)
  {
    this.mOnGestureLockViewListener = listener;
  } 

  /**
   * 对外公布设置答案的方法
   *
   * @param answer
   */
  public void setAnswer(int[] answer)
  {
    this.mAnswer = answer;
  } 

  /**
   * 设置最大实验次数
   *
   * @param boundary
   */
  public void setUnMatchExceedBoundary(int boundary)
  {
    this.mTryTimes = boundary;
  } 

  @Override
  public void dispatchDraw(Canvas canvas)
  {
    super.dispatchDraw(canvas);
    //绘制GestureLockView间的连线
    if (mPath != null)
    {
      canvas.drawPath(mPath, mPaint);
    }
    //绘制指引线
    if (mChoose.size() > 0)
    {
      if (mLastPathX != 0 && mLastPathY != 0)
        canvas.drawLine(mLastPathX, mLastPathY, mTmpTarget.x,
            mTmpTarget.y, mPaint);
    } 

  } 

  public interface OnGestureLockViewListener
  {
    /**
     * 单独选中元素的Id
     *
     * @param position
     */
    public void onBlockSelected(int cId); 

    /**
     * 是否匹配
     *
     * @param matched
     */
    public void onGestureEvent(boolean matched); 

    /**
     * 超过尝试次数
     */
    public void onUnmatchedExceedBoundary();
  }
}

注释极其详细,用极其不过分~主要就是onTouchEvent中对用户选择的GestureLockView进行判断,以及改变GestureLockView状态等。

5、布局文件

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
  xmlns:tools="http://schemas.android.com/tools"
  xmlns:zhy="http://schemas.android.com/apk/res/com.zhy.zhy_gesturelockview"
  android:layout_width="match_parent"
  android:layout_height="match_parent" > 

  <com.zhy.zhy_gesturelockview.view.GestureLockViewGroup
    android:id="@+id/id_gestureLockViewGroup"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:background="#F2F2F7"
    android:gravity="center_vertical"
    zhy:count="3"
    zhy:tryTimes="5" />
<!--  zhy:color_no_finger_inner_circle="#ff085D58"
    zhy:color_no_finger_outer_circle="#ff08F0E0"
    zhy:color_finger_on="#FF1734BF" --> 

</RelativeLayout>

有兴趣的可以自定义属性,把注释的代码添进去就行,当然你也可以什么都不设置,单纯设置宽度和高度,我觉得默认效果也是不错的 ~

6、调用

package com.zhy.zhy_gesturelockview; 

import android.app.Activity;
import android.os.Bundle;
import android.widget.Toast; 

import com.zhy.zhy_gesturelockview.view.GestureLockViewGroup;
import com.zhy.zhy_gesturelockview.view.GestureLockViewGroup.OnGestureLockViewListener; 

public class MainActivity extends Activity
{ 

  private GestureLockViewGroup mGestureLockViewGroup; 

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

    mGestureLockViewGroup = (GestureLockViewGroup) findViewById(R.id.id_gestureLockViewGroup);
    mGestureLockViewGroup.setAnswer(new int[] { 1, 2, 3, 4,5 });
    mGestureLockViewGroup
        .setOnGestureLockViewListener(new OnGestureLockViewListener()
        { 

          @Override
          public void onUnmatchedExceedBoundary()
          {
            Toast.makeText(MainActivity.this, "错误5次...",
                Toast.LENGTH_SHORT).show();
            mGestureLockViewGroup.setUnMatchExceedBoundary(5);
          } 

          @Override
          public void onGestureEvent(boolean matched)
          {
            Toast.makeText(MainActivity.this, matched+"",
                Toast.LENGTH_SHORT).show();
          } 

          @Override
          public void onBlockSelected(int cId)
          {
          }
        });
  } 

}
(0)

相关推荐

  • Android 九宫格的实现方法

    1.xml代码: 复制代码 代码如下: <?xml version="1.0" encoding="utf-8"?>  <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"       android:orientation="vertical"      android:layout_width="fill

  • Android实现九宫格(GridView中各项平分空间)的方法

    本文实例讲述了Android实现九宫格(GridView中各项平分空间)的方法.分享给大家供大家参考.具体如下: 项目需要做一个九宫格(也不一定是9的,4宫格.16宫格.4x3宫格...),封了 一个宫格,它能够根据为它分配的空间来自动的调节宫中各项的尺寸. 从TableLayout集成来的,因此如果你直接在设计器上使用该封装的话需要把它自动加进去的那几个TableRow删除一下. 类名为AdvancedGridView,代码如下: import android.content.Context;

  • Android开发之实现GridView支付宝九宫格

    先给大家展示下关于仿支付宝钱包首页中带有分割线的gridview,俗称九宫格 的效果图,怎么样是不是和你想象的一样啊.在你的预料之中就继续访问以下代码内容吧. 我们都知道ListView设置分割线是非常容易的,设置ListView的分割线颜色和宽度,只需要在布局中定义android:divider和android:dividerHeight属性即可.而GridView并没有这样的属性和方法,那我们改如何来做呢? 我们小编在做这个效果之前,也参考了其他的一些方案,比如说定义一个自定义的GridVi

  • Android 自定义九宫格手势锁

    预览效果图如下: 主要的方法是重写View.onTouchEvent( MotionEvent event ) , 常用的三个操作:ACTION_DOWN 手指触摸屏幕 ; ACTION_UP 手指离开屏幕; ACTION_MOVE手指在屏幕滑动. 如果该方法返回true ,表示该事件已经被View处理,不再向上层的View或Activity传递 : 如果返回false, 表示事件未处理,继续传递. 具体代码如下: package com.ninegrid; import android.con

  • android 九宫格滑动解锁开机实例源码学习

    效果图由于网站占时不能上传,以后补上. NinePointLineView.java 复制代码 代码如下: package org.demo.custon_view; import org.demo.utils.MLog; import android.content.Context; import android.graphics.Bitmap; import android.graphics.BitmapFactory; import android.graphics.Canvas; imp

  • 超实用的Android手势锁制作实例教程

    今天偶遇以github上gesturelock关于手势锁的一个例子(有兴趣的去搜索下看看),于是下载下来研究,无奈基本没有注释,代码上存在一些问题(当设置gravity=center_vertical无法进行手势选择,无意中发现的),于是借鉴这位仁兄的代码,自己重写写了一个,修复了一些问题,加入一些基本的自定义属性,在此先感谢这位兄弟~. 先上图,默认效果图: 当然可以自定义数量啊,颜色神马的,自定义效果图: 如果你有艺术细胞,可以给我推荐几个颜色,无奈个人审美有问题~ 1.整体思路 a.自定义

  • 微信小程序实现之手势锁功能实例代码

    设计思路流程图 1.全局常量 constructor(page,opts){ // 初始化全局常量数据 this.page = page; this.width = opts.width || 300; this.height = opts.height || 300; this.canvasId = opts.canvasId || 'lock'; this.type = opts.type || 3; this.cleColor = opts.cleColor || 'rgba(0,136,

  • Android手势操作简单实例讲解

    上一篇介绍的onTouch提供的事件还是相对较简单,如果需要处理一些复杂的手势,用这个接口就会很麻烦,因为我们要根据用户触摸的轨迹去判断是什么手势.幸好Android SDK给我们提供了GestureDetector类,通过这个类我们可以识别很多的手势,主要是通过他的onTouchEvent(event)方法完成了不同手势的识别. GestureDetector这个类对外提供了两个接口和一个外部类:  •接口:OnGestureListener,OnDoubleTapListener  •外部类

  • Android手势密码实现实例代码

    一.效果实现 二.实现思路: 1. 正上方的提示区域,用一个类(LockIndicator.java)来实现,自定义view来绘制9个提示图标: 2. 手势密码绘制区域,用一个类(GestureContentView.java)来实现,它继承自ViewGroup里面, 添加9个ImageView来表示图标, 在onLayout()方法中设置它们的位置: 3. 手势路径绘制, 用一个类(GestureDrawline.java)来实现,复写onTouchEvent()方法,在这个方法里面监听Tou

  • Android 手势 正则匹配图片实例代码

    为没有手势的控件(ViewFlipper) 添加手势 xml <?xml version="1.0" encoding="utf-8"?> <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" xmlns:app="http://schemas.android.com/apk/res-auto" xmlns:tools

  • Flutter中嵌入Android 原生TextView实例教程

    前言 本篇文章 中写到的是 flutter 调用了Android 原生的 TextView 案例 添加原生组件的流程基本上可以描述为: 1 android 端实现原生组件PlatformView提供原生view 2 android 端创建PlatformViewFactory用于生成PlatformView 3 android 端创建FlutterPlugin用于注册原生组件 4 flutter 平台嵌入 原生view 1 创建原生组件 创建在fLutter工程时会生成几个文件夹,lib是放fl

  • 分布式锁实例教程之防止重复提交

    目录 抛出一个问题 正常的代码逻辑 1.注册controller 2.注册service 3.加入分布式锁,问题依旧 解决方法 分布式锁+防重操作 总结 抛出一个问题 需求:现在有一个常见的场景--用户注册,但是如果出现重复提交的情况,则会出现多条注册数据,因此这里如何做好防止重复提交这是我们需要解决的问题. 正常的代码逻辑 1.注册controller /** * 用户注册请求 * @param userDto * @param bindingResult * @return */ @Requ

  • MySQL事务与锁实例教程详解

    目录 MySQL事务和锁 事务 事务的控制语句 事务隔离级别设置 脏读 不可重复读 幻读 锁机制 InnoDB的行级锁 锁实战 死锁 总结 MySQL事务和锁 事务 说到关系型的数据库的事务,相信大家对四大特性都不陌生,分别是原子性.一致性.隔离性.持久性,简称为ACID特性. MySQL中支持3种不同的存储引擎: MyISAM存储引擎.Memory存储引擎.和InnoDB存储引擎 注:只有InnoDB才支持事务. 事务的控制语句 控制语句 作用 begin或者start transaction

  • Android编程之SurfaceView实例详解

    本文实例讲述了Android编程之SurfaceView用法.分享给大家供大家参考,具体如下: 关于surfaceView相关知识: View和SurfaceView主要区别: 1. View只能在UI线程中刷新,而SurfaceView可以在子线程中刷新 2. SurfaceView可以控制刷新频率 SurfaceView几个重要的方法: 1. 继承SurfaceView 后调用getHolder()方法可以获取到mSurfaceHolder对象这个对于可以控制SurfaceView的绘制 2

随机推荐