2024年Android最新android 电子签名 手写签名 功能实现(1)，阿里hr面试题

最后：学习总结——Android框架体系架构知识脑图（纯手绘xmind文档）

学完之后，若是想验收效果如何，其实最好的方法就是可自己去总结一下。比如我就会在学习完一个东西之后自己去手绘一份xmind文件的知识梳理大纲脑图，这样也可方便后续的复习，且都是自己的理解，相信随便瞟几眼就能迅速过完整个知识，脑补回来。

下方即为我手绘的Android框架体系架构知识脑图，由于是xmind文件，不好上传，所以小编将其以图片形式导出来传在此处，细节方面不是特别清晰。但可给感兴趣的朋友提供完整的Android框架体系架构知识脑图原件（包括上方的面试解析xmind文档）

除此之外，前文所提及的Alibaba珍藏版 Android框架体系架构 手写文档以及一本 《大话数据结构》 书籍等等相关的学习笔记文档，也皆可分享给认可的朋友！

——感谢大家伙的认可支持，请注意：点赞+点赞+点赞！！！

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化学习资料的朋友，可以戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

@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;

TimedPoint m1 = new TimedPoint((s1.x + s2.x) / 2.0f, (s1.y + s2.y) / 2.0f);

TimedPoint m2 = new TimedPoint((s2.x + s3.x) / 2.0f, (s2.y + s3.y) / 2.0f);

float l1 = (float) Math.sqrt(dx1 * dx1 + dy1 * dy1);

float l2 = (float) Math.sqrt(dx2 * dx2 + dy2 * dy2);

float dxm = (m1.x - m2.x);

float dym = (m1.y - m2.y);

float k = l2 / (l1 + l2);

TimedPoint cm = new TimedPoint(m2.x + dxm * k, m2.y + dym * k);

float tx = s2.x - cm.x;

float ty = s2.y - cm.y;

return new ControlTimedPoints(new TimedPoint(m1.x + tx, m1.y + ty), new TimedPoint(m2.x + tx, m2.y + ty));

}

private float strokeWidth(float velocity) {

return Math.max(mMaxWidth / (velocity + 1), mMinWidth);

}

/**

• Called when replaying history to ensure the dirty region includes all

• mPoints.

• @param historicalX

•        the previous x coordinate.
  

• @param historicalY

•        the previous y coordinate.
  

*/

private void expandDirtyRect(float historicalX, float historicalY) {

if (historicalX < mDirtyRect.left) {

mDirtyRect.left = historicalX;

} else if (historicalX > mDirtyRect.right) {

mDirtyRect.right = historicalX;

}

if (historicalY < mDirtyRect.top) {

mDirtyRect.top = historicalY;

} else if (historicalY > mDirtyRect.bottom) {

mDirtyRect.bottom = historicalY;

}

}

/**

• Resets the dirty region when the motion event occurs.

• @param eventX

•        the event x coordinate.
  

• @param eventY

•        the event y coordinate.
  

*/

private void resetDirtyRect(float eventX, float eventY) {

// The mLastTouchX and mLastTouchY were set when the ACTION_DOWN motion

// event occurred.

mDirtyRect.left = Math.min(mLastTouchX, eventX);

mDirtyRect.right = Math.max(mLastTouchX, eventX);

mDirtyRect.top = Math.min(mLastTouchY, eventY);

mDirtyRect.bottom = Math.max(mLastTouchY, eventY);

}

private void setIsEmpty(boolean newValue) {

mIsEmpty = newValue;

if (mOnSignedListener != null) {

if (mIsEmpty) {

mOnSignedListener.onClear();

} else {

mOnSignedListener.onSigned();

}

}

}

private void ensureSignatureBitmap() {

if (mSignatureBitmap == null) {

mSignatureBitmap = Bitmap.createBitmap(getWidth(), getHeight(), Bitmap.Config.ARGB_8888);

mSignatureBitmapCanvas = new Canvas(mSignatureBitmap);

}

}

private int convertDpToPx(float dp) {

return Math.round(dp * (getResources().getDisplayMetrics().xdpi / DisplayMetrics.DENSITY_DEFAULT));

}

public interface OnSignedListener {

public void onSigned();

public void onClear();

}

}

Demo源码下载链接

最后

今天关于面试的分享就到这里，还是那句话，有些东西你不仅要懂，而且要能够很好地表达出来，能够让面试官认可你的理解，例如Handler机制，这个是面试必问之题。有些晦涩的点，或许它只活在面试当中，实际工作当中你压根不会用到它，但是你要知道它是什么东西。

最后在这里小编分享一份自己收录整理上述技术体系图相关的几十套腾讯、头条、阿里、美团等公司2021年的面试题，把技术点整理成了视频和PDF（实际上比预期多花了不少精力），包含知识脉络 + 诸多细节，由于篇幅有限，这里以图片的形式给大家展示一部分。

还有 高级架构技术进阶脑图、Android开发面试专题资料，高级进阶架构资料 帮助大家学习提升进阶，也节省大家在网上搜索资料的时间来学习，也可以分享给身边好友一起学习。

【Android核心高级技术PDF文档，BAT大厂面试真题解析】

【算法合集】

【延伸Android必备知识点】

【Android部分高级架构视频学习资源】

Android精讲视频领取学习后更加是如虎添翼！进军BATJ大厂等（备战）！现在都说互联网寒冬，其实无非就是你上错了车，且穿的少（技能），要是你上对车，自身技术能力够强，公司换掉的代价大，怎么可能会被裁掉，都是淘汰末端的业务Curd而已！现如今市场上初级程序员泛滥，这套教程针对Android开发工程师1-6年的人员、正处于瓶颈期，想要年后突破自己涨薪的，进阶Android中高级、架构师对你更是如鱼得水，赶快领取吧！

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化学习资料的朋友，可以戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

档，BAT大厂面试真题解析】**

[外链图片转存中…(img-cbGWIdRq-1715651452196)]

【算法合集】

[外链图片转存中…(img-IglzI99F-1715651452196)]

【延伸Android必备知识点】

[外链图片转存中…(img-q6DT6TNj-1715651452197)]

【Android部分高级架构视频学习资源】

Android精讲视频领取学习后更加是如虎添翼！进军BATJ大厂等（备战）！现在都说互联网寒冬，其实无非就是你上错了车，且穿的少（技能），要是你上对车，自身技术能力够强，公司换掉的代价大，怎么可能会被裁掉，都是淘汰末端的业务Curd而已！现如今市场上初级程序员泛滥，这套教程针对Android开发工程师1-6年的人员、正处于瓶颈期，想要年后突破自己涨薪的，进阶Android中高级、架构师对你更是如鱼得水，赶快领取吧！

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化学习资料的朋友，可以戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！