您现在的位置是：首页 >其他 >android 电子签名 手写签名 功能实现网站首页其他

这个手写的效果 就是一个 重写的的自定义的view  代码如下：

package com.example.hand.views;

import java.util.ArrayList;

import java.util.List;

import android.content.Context;

import android.content.res.Resources;

import android.content.res.TypedArray;

import android.graphics.Bitmap;

import android.graphics.Canvas;

import android.graphics.Color;

import android.graphics.Matrix;

import android.graphics.Paint;

import android.graphics.Path;

import android.graphics.RectF;

import android.util.AttributeSet;

import android.util.DisplayMetrics;

import android.view.MotionEvent;

import android.view.View;

import com.example.hand.R;

import com.example.hand.utils.Bezier;

import com.example.hand.utils.ControlTimedPoints;

import com.example.hand.utils.TimedPoint;

public class SignatureView extends View {

// View state

private List mPoints;

private boolean mIsEmpty;

private float mLastTouchX;

private float mLastTouchY;

private float mLastVelocity;

private float mLastWidth;

private RectF mDirtyRect;

// Configurable parameters

private int mMinWidth;

private int mMaxWidth;

private float mVelocityFilterWeight;

private OnSignedListener mOnSignedListener;

private Paint mPaint = new Paint();

private Path mPath = new Path();

private Bitmap mSignatureBitmap = null;

private Canvas mSignatureBitmapCanvas = null;

public SignatureView(Context context, AttributeSet attrs) {

super(context, attrs);

TypedArray a = context.getTheme().obtainStyledAttributes(attrs, R.styleable.SignatureView, 0, 0);

// Configurable parameters

try {

mMinWidth = a.getDimensionPixelSize(R.styleable.SignatureView_minWidth, convertDpToPx(3));

mMaxWidth = a.getDimensionPixelSize(R.styleable.SignatureView_maxWidth, convertDpToPx(7));

mVelocityFilterWeight = a.getFloat(R.styleable.SignatureView_velocityFilterWeight, 0.9f);

mPaint.setColor(a.getColor(R.styleable.SignatureView_penColor, Color.BLACK));

} finally {

a.recycle();

}

// Fixed parameters

mPaint.setAntiAlias(true);

mPaint.setStyle(Paint.Style.STROKE);

mPaint.setStrokeCap(Paint.Cap.ROUND);

mPaint.setStrokeJoin(Paint.Join.ROUND);

// Dirty rectangle to update only the changed portion of the view

mDirtyRect = new RectF();

clear();

}

/**

• Set the pen color from a given resource. If the resource is not found,

• {@link android.graphics.Color#BLACK} is assumed.

• @param colorRes

•        the color resource.
  

*/

public void setPenColorRes(int colorRes) {

try {

setPenColor(getResources().getColor(colorRes));

} catch (Resources.NotFoundException ex) {

setPenColor(getResources().getColor(Color.BLACK));

}

}

/**

• Set the pen color from a given color.

• @param color

•        the color.
  

*/

public void setPenColor(int color) {

mPaint.setColor(color);

}

/**

• Set the minimum width of the stroke in pixel.

• @param minWidth

•        the width in dp.
  

*/

public void setMinWidth(float minWidth) {

mMinWidth = convertDpToPx(minWidth);

}

/**

• Set the maximum width of the stroke in pixel.

• @param maxWidth

•        the width in dp.
  

*/

public void setMaxWidth(float maxWidth) {

mMaxWidth = convertDpToPx(maxWidth);

}

/**

• Set the velocity filter weight.

• @param velocityFilterWeight

•        the weight.
  

*/

public void setVelocityFilterWeight(float velocityFilterWeight) {

mVelocityFilterWeight = velocityFilterWeight;

}

public void clear() {

mPoints = new ArrayList();

mLastVelocity = 0;

mLastWidth = (mMinWidth + mMaxWidth) / 2;

mPath.reset();

if (mSignatureBitmap != null) {

mSignatureBitmap = null;

ensureSignatureBitmap();

}

setIsEmpty(true);

invalidate();

}

@Override

public boolean onTouchEvent(MotionEvent event) {

if (!isEnabled())

return false;

float eventX = event.getX();

float eventY = event.getY();

switch (event.getAction()) {

case MotionEvent.ACTION_DOWN:

getParent().requestDisallowInterceptTouchEvent(true);

mPoints.clear();

mPath.moveTo(eventX, eventY);

mLastTouchX = eventX;

mLastTouchY = eventY;

addPoint(new TimedPoint(eventX, eventY));

case MotionEvent.ACTION_MOVE:

resetDirtyRect(eventX, eventY);

addPoint(new TimedPoint(eventX, eventY));

break;

case MotionEvent.ACTION_UP:

resetDirtyRect(eventX, eventY);

addPoint(new TimedPoint(eventX, eventY));

getParent().requestDisallowInterceptTouchEvent(true);

setIsEmpty(false);

break;

default:

return false;

}

// invalidate();

invalidate((int) (mDirtyRect.left - mMaxWidth), (int) (mDirtyRect.top - mMaxWidth),

(int) (mDirtyRect.right + mMaxWidth), (int) (mDirtyRect.bottom + mMaxWidth));

return true;

}

@Override

protected void onDraw(Canvas canvas) {

if (mSignatureBitmap != null) {

canvas.drawBitmap(mSignatureBitmap, 0, 0, mPaint);

}

}

public void setOnSignedListener(OnSignedListener listener) {

mOnSignedListener = listener;

}

public boolean isEmpty() {

return mIsEmpty;

}

public Bitmap getSignatureBitmap() {

Bitmap originalBitmap = getTransparentSignatureBitmap();

Bitmap whiteBgBitmap = Bitmap.createBitmap(originalBitmap.getWidth(), originalBitmap.getHeight(),

Bitmap.Config.ARGB_8888);

Canvas canvas = new Canvas(whiteBgBitmap);

canvas.drawColor(Color.WHITE);

canvas.drawBitmap(originalBitmap, 0, 0, null);

return whiteBgBitmap;

}

public void setSignatureBitmap(Bitmap signature) {

clear();

ensureSignatureBitmap();

RectF tempSrc = new RectF();

RectF tempDst = new RectF();

int dWidth = signature.getWidth();

int dHeight = signature.getHeight();

int vWidth = getWidth();

int vHeight = getHeight();

// Generate the required transform.

tempSrc.set(0, 0, dWidth, dHeight);

tempDst.set(0, 0, vWidth, vHeight);

Matrix drawMatrix = new Matrix();

drawMatrix.setRectToRect(tempSrc, tempDst, Matrix.ScaleToFit.CENTER);

Canvas canvas = new Canvas(mSignatureBitmap);

canvas.drawBitmap(signature, drawMatrix, null);

setIsEmpty(false);

invalidate();

}

public Bitmap getTransparentSignatureBitmap() {

ensureSignatureBitmap();

return mSignatureBitmap;

}

public Bitmap getTransparentSignatureBitmap(boolean trimBlankSpace) {

if (!trimBlankSpace) {

return getTransparentSignatureBitmap();

}

ensureSignatureBitmap();

int imgHeight = mSignatureBitmap.getHeight();

int imgWidth = mSignatureBitmap.getWidth();

int backgroundColor = Color.TRANSPARENT;

int xMin = Integer.MAX_VALUE, xMax = Integer.MIN_VALUE, yMin = Integer.MAX_VALUE, yMax = Integer.MIN_VALUE;

boolean foundPixel = false;

// Find xMin

for (int x = 0; x < imgWidth; x++) {

boolean stop = false;

for (int y = 0; y < imgHeight; y++) {

if (mSignatureBitmap.getPixel(x, y) != backgroundColor) {

xMin = x;

stop = true;

foundPixel = true;

break;

}

}

if (stop)

break;

}

// Image is empty…

if (!foundPixel)

return null;

// Find yMin

for (int y = 0; y < imgHeight; y++) {

boolean stop = false;

for (int x = xMin; x < imgWidth; x++) {

if (mSignatureBitmap.getPixel(x, y) != backgroundColor) {

yMin = y;

stop = true;

break;

}

}

if (stop)

break;

}

// Find xMax

for (int x = imgWidth - 1; x >= xMin; x–) {

boolean stop = false;

for (int y = yMin; y < imgHeight; y++) {

if (mSignatureBitmap.getPixel(x, y) != backgroundColor) {

xMax = x;

stop = true;

break;

}

}

if (stop)

break;

}

// Find yMax

for (int y = imgHeight - 1; y >= yMin; y–) {

boolean stop = false;

for (int x = xMin; x <= xMax; x++) {

if (mSignatureBitmap.getPixel(x, y) != backgroundColor) {

yMax = y;

stop = true;

break;

}

}

if (stop)

break;

}

return Bitmap.createBitmap(mSignatureBitmap, xMin, yMin, xMax - xMin, yMax - yMin);

}

private void addPoint(TimedPoint newPoint) {

mPoints.add(newPoint);

if (mPoints.size() > 2) {

// To reduce the initial lag make it work with 3 mPoints

// by copying the first point to the beginning.

if (mPoints.size() == 3)

mPoints.add(0, mPoints.get(0));

ControlTimedPoints tmp = calculateCurveControlPoints(mPoints.get(0), mPoints.get(1), mPoints.get(2));

TimedPoint c2 = tmp.c2;

tmp = calculateCurveControlPoints(mPoints.get(1), mPoints.get(2), mPoints.get(3));

TimedPoint c3 = tmp.c1;

Bezier curve = new Bezier(mPoints.get(1), c2, c3, mPoints.get(2));

TimedPoint startPoint = curve.startPoint;

TimedPoint endPoint = curve.endPoint;

float velocity = endPoint.velocityFrom(startPoint);

velocity = Float.isNaN(velocity) ? 0.0f : velocity;

velocity = mVelocityFilterWeight * velocity + (1 - mVelocityFilterWeight) * mLastVelocity;

// The new width is a function of the velocity. Higher velocities

// correspond to thinner strokes.

float newWidth = strokeWidth(velocity);

// The Bezier’s width starts out as last curve’s final width, and

// gradually changes to the stroke width just calculated. The new

// width calculation is based on the velocity between the Bezier’s

// start and end mPoints.

addBezier(curve, mLastWidth, newWidth);

mLastVelocity = velocity;

mLastWidth = newWidth;

// Remove the first element from the list,

// so that we always have no more than 4 mPoints in mPoints array.

mPoints.remove(0);

}

}

private void addBezier(Bezier curve, float startWidth, float endWidth) {

ensureSignatureBitmap();

float originalWidth = mPaint.getStrokeWidth();

float widthDelta = endWidth - startWidth;

float drawSteps = (float) Math.floor(curve.length());

for (int i = 0; i < drawSteps; i++) {

// Calculate the Bezier (x, y) coordinate for this step.

float t = ((float) i) / drawSteps;

float tt = t * t;

float ttt = tt * t;

float u = 1 - t;

float uu = u * u;

float uuu = uu * u;

float x = uuu * curve.startPoint.x;

x += 3 * uu * t * curve.control1.x;

x += 3 * u * tt * curve.control2.x;

x += ttt * curve.endPoint.x;

float y = uuu * curve.startPoint.y;

y += 3 * uu * t * curve.control1.y;

y += 3 * u * tt * curve.control2.y;

y += ttt * curve.endPoint.y;

// Set the incremental stroke width and draw.

mPaint.setStrokeWidth(startWidth + ttt * widthDelta);

mSignatureBitmapCanvas.drawPoint(x, y, mPaint);

expandDirtyRect(x, y);

}

mPaint.setStrokeWidth(originalWidth);

}

private ControlTimedPoints calculateCurveControlPoints(TimedPoint s1, TimedPoint s2, TimedPoint s3) {

float dx1 = s1.x - s2.x;

float dy1 = s1.y - s2.y;

float dx2 = s2.x - s3.x;

float dy2 = s2.y - s3.y;