Android最全android 电子签名手写签名功能实现(2)，2024年最新我的头条面试经历分享

最新推荐文章于 2024-05-14 09:51:14 发布

2401_84562768

最新推荐文章于 2024-05-14 09:51:14 发布

阅读量409

点赞数 3

分类专栏：程序员文章标签： android 面试学习

本文链接：https://blog.csdn.net/2401_84562768/article/details/138608591

版权

程序员专栏收录该内容

188 篇文章 0 订阅

订阅专栏

最后

总而言之，成功是留给准备好的人的。无论是参加什么面试，都要做好充足的准备，注意好面试的礼仪和穿着，向面试官表现出自己的热忱与真诚就好。即使最后没有过关，也要做好经验的总结，为下一次面试做好充足准备。

这里我为大家准备了一些我在面试后整理的面试专题资料，除了面试题，还总结出了互联网公司Android程序员面试涉及到的绝大部分面试题及答案，并整理做成了文档，以及系统的进阶学习视频资料分享给大家，希望能帮助到你面试前的复习，且找到一个好的工作，也节省大家在网上搜索资料的时间来学习。

毕竟不管遇到什么样的面试官，去面试首先最主要的就是自己的实力，只要实力够硬，技术够强，就不怕面试拿不到offer！

为什么某些人会一直比你优秀，是因为他本身就很优秀还一直在持续努力变得更优秀，而你是不是还在满足于现状内心在窃喜！希望读到这的您能点个小赞和关注下我，以后还会更新技术干货，谢谢您的支持！

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

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

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

}

/**

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;

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.

最后

都说三年是程序员的一个坎，能否晋升或者提高自己的核心竞争力，这几年就十分关键。

技术发展的这么快，从哪些方面开始学习，才能达到高级工程师水平，最后进阶到Android架构师/技术专家？我总结了这 5大块；

我搜集整理过这几年阿里，以及腾讯，字节跳动，华为，小米等公司的面试题，把面试的要求和技术点梳理成一份大而全的“ Android架构师”面试 Xmind（实际上比预期多花了不少精力），包含知识脉络 + 分支细节。

网上学习 Android的资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。希望这份系统化的技术体系对大家有一个方向参考。

2021年虽然路途坎坷，都在说Android要没落，但是，不要慌，做自己的计划，学自己的习，竞争无处不在，每个行业都是如此。相信自己，没有做不到的，只有想不到的。祝大家2021年万事大吉。

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

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

整理过这几年阿里，以及腾讯，字节跳动，华为，小米等公司的面试题，把面试的要求和技术点梳理成一份大而全的“ Android架构师”面试 Xmind（实际上比预期多花了不少精力），包含知识脉络 + 分支细节。

[外链图片转存中…(img-FdqOfsqi-1715228332727)]

[外链图片转存中…(img-gYYzhLPo-1715228332728)]

[外链图片转存中…(img-Qqjh7Eou-1715228332728)]

2021年虽然路途坎坷，都在说Android要没落，但是，不要慌，做自己的计划，学自己的习，竞争无处不在，每个行业都是如此。相信自己，没有做不到的，只有想不到的。祝大家2021年万事大吉。

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

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

2401_84562768

关注

3
点赞
踩
4

收藏

觉得还不错? 一键收藏
0
评论
Android最全android 电子签名手写签名功能实现(2)，2024年最新我的头条面试经历分享

总而言之，成功是留给准备好的人的。无论是参加什么面试，都要做好充足的准备，注意好面试的礼仪和穿着，向面试官表现出自己的热忱与真诚就好。即使最后没有过关，也要做好经验的总结，为下一次面试做好充足准备。这里我为大家准备了一些我在面试后整理的面试专题资料，除了面试题，还总结出了互联网公司Android程序员面试涉及到的绝大部分面试题及答案，并整理做成了文档，以及系统的进阶学习视频资料分享给大家，希望能帮助到你面试前的复习，且找到一个好的工作，也节省大家在网上搜索资料的时间来学习。
复制链接

扫一扫