【移动应用开发技术】怎么在Android中使用SurfaceView实现一个点赞动画

【移动应用开发技术】怎么在Android中使用SurfaceView实现一个点赞动画

这期内容当中在下将会给大家带来有关怎么在Android中使用SurfaceView实现一个点赞动画，文章内容丰富且以专业的角度为大家分析和叙述，阅读完这篇文章希望大家可以有所收获。ZanBean类，每个ZanBean都要负责实时更新自己的位置、透明度等数据import

android.animation.TypeEvaluator;

import

android.animation.ValueAnimator;

import

android.annotation.TargetApi;

import

android.content.Context;

import

android.graphics.Bitmap;

import

android.graphics.BitmapFactory;

import

android.graphics.Canvas;

import

android.graphics.Matrix;

import

android.graphics.Paint;

import

android.graphics.Point;

import

android.os.Build;

import

java.util.Random;

public

class

ZanBean

{

/**

*

心的当前坐标

*/

public

Point

point;

/**

*

移动动画

*/

private

ValueAnimator

moveAnim;

/**

*

放大动画

*/

private

ValueAnimator

zoomAnim;

/**

*

透明度

*/

public

int

alpha

=

255;//

/**

*

心图

*/

private

Bitmap

bitmap;

/**

*

绘制bitmap的矩阵

用来做缩放和移动的

*/

private

Matrix

matrix

=

new

Matrix();

/**

*

缩放系数

*/

private

float

sf

=

0;

/**

*

产生随机数

*/

private

Random

random;

public

boolean

isEnd

=

false;//是否结束

public

ZanBean(Context

context,

int

resId,

ZanView

zanView)

{

random

=

new

Random();

bitmap

=

BitmapFactory.decodeResource(context.getResources(),

resId);

init(new

Point(zanView.getWidth()

/

2,

zanView.getHeight()-

bitmap.getHeight()

/

2),

new

Point((random.nextInt(zanView.getWidth())),

0));

}

public

ZanBean(Bitmap

bitmap,

ZanView

zanView)

{

random

=

new

Random();

this.bitmap

=

bitmap;

//为了让在起始坐标点时显示完整

需要减去bitmap.getHeight()/2

init(new

Point(zanView.getWidth()

/

2,

zanView.getHeight()

-

bitmap.getHeight()

/

2),

new

Point((random.nextInt(zanView.getWidth())),

0));

}

@TargetApi(Build.VERSION_CODES.HONEYCOMB)

private

void

init(final

Point

startPoint,

Point

endPoint)

{

moveAnim

=

ValueAnimator.ofObject(new

BezierEvaluator(new

Point(random.nextInt(startPoint.x

*

2),

Math.abs(endPoint.y

-

startPoint.y)

/

2)),

startPoint,

endPoint);

moveAnim.setDuration(1500);

moveAnim.addUpdateListener(new

ValueAnimator.AnimatorUpdateListener()

{

@Override

public

void

onAnimationUpdate(ValueAnimator

animation)

{

point

=

(Point)

animation.getAnimatedValue();

alpha

=

(int)

((float)

point.y

/

(float)

startPoint.y

*

255);

}

});

moveAnim.start();

zoomAnim

=

ValueAnimator.ofFloat(0,

1f).setDuration(700);

zoomAnim.addUpdateListener(new

ValueAnimator.AnimatorUpdateListener()

{

@Override

public

void

onAnimationUpdate(ValueAnimator

animation)

{

Float

f

=

(Float)

animation.getAnimatedValue();

sf

=

f.floatValue();

}

});

zoomAnim.start();

}

//

public

void

pause(){

//

if(moveAnim

!=null&&

moveAnim.isRunning()){

//

moveAnim.pause();

//

}

//

if(zoomAnim

!=null&&

zoomAnim.isRunning()){

//

zoomAnim.pause();

//

}

//

}

//

//

public

void

resume(){

//

if(moveAnim

!=null&&

moveAnim.isPaused()){

//

moveAnim.resume();

//

}

//

if(zoomAnim

!=null&&

zoomAnim.isPaused()){

//

zoomAnim.resume();

//

}

//

}

public

void

stop()

{

if

(moveAnim

!=

null)

{

moveAnim.cancel();

moveAnim

=

null;

}

if

(zoomAnim

!=

null)

{

zoomAnim.cancel();

zoomAnim

=

null;

}

}

/**

*

主要绘制函数

*/

public

void

draw(Canvas

canvas,

Paint

p)

{

if

(bitmap

!=

null

&&

alpha

>

0)

{

p.setAlpha(alpha);

matrix.setScale(sf,

sf,

bitmap.getWidth()

/

2,

bitmap.getHeight()

/

2);

matrix.postTranslate(point.x

-

bitmap.getWidth()

/

2,

point.y

-

bitmap.getHeight()

/

2);

canvas.drawBitmap(bitmap,

matrix,

p);

}

else

{

isEnd

=

true;

}

}

/**

*

二次贝塞尔曲线

*/

@TargetApi(Build.VERSION_CODES.HONEYCOMB)

private

class

BezierEvaluator

implements

TypeEvaluator<Point>

{

private

Point

centerPoint;

public

BezierEvaluator(Point

centerPoint)

{

this.centerPoint

=

centerPoint;

}

@Override

public

Point

evaluate(float

t,

Point

startValue,

Point

endValue)

{

int

x

=

(int)

((1

-

t)

*

(1

-

t)

*

startValue.x

+

2

*

t

*

(1

-

t)

*

centerPoint.x

+

t

*

t

*

endValue.x);

int

y

=

(int)

((1

-

t)

*

(1

-

t)

*

startValue.y

+

2

*

t

*

(1

-

t)

*

centerPoint.y

+

t

*

t

*

endValue.y);

return

new

Point(x,

y);

}

}

}ZanView代码如下:SurfaceView,不断将ZanBean画到自己的画布上。import

android.content.Context;

import

android.graphics.Canvas;

import

android.graphics.Color;

import

android.graphics.Paint;

import

android.graphics.PixelFormat;

import

android.graphics.PorterDuff;

import

android.util.AttributeSet;

import

android.view.SurfaceHolder;

import

android.view.SurfaceView;

import

java.util.ArrayList;

public

class

ZanView

extends

SurfaceView

implements

SurfaceHolder.Callback

{

private

SurfaceHolder

surfaceHolder;

/**

*

心的个数

*/

private

ArrayList<ZanBean>

zanBeen

=

new

ArrayList<>();

private

Paint

p;

/**

*

负责绘制的工作线程

*/

private

DrawThread

drawThread;

public

ZanView(Context

context)

{

this(context,

null);

}

public

ZanView(Context

context,

AttributeSet

attrs)

{

this(context,

attrs,

0);

}

public

ZanView(Context

context,

AttributeSet

attrs,

int

defStyleAttr)

{

super(context,

attrs,

defStyleAttr);

this.setZOrderOnTop(true);

/**设置画布

背景透明*/

this.getHolder().setFormat(PixelFormat.TRANSLUCENT);

surfaceHolder

=

getHolder();

surfaceHolder.addCallback(this);

p

=

new

Paint();

p.setAntiAlias(true);

drawThread

=

new

DrawThread();

}

/**

*

点赞动作

添加心的函数

控制画面最大心的个数

*/

public

void

addZanXin(ZanBean

zanBean)

{

zanBeen.add(zanBean);

if

(zanBeen.size()

>

40)

{

zanBeen.remove(0);

}

start();

}

@Override

public

void

surfaceCreated(SurfaceHolder

holder)

{

if

(drawThread

==

null)

{

drawThread

=

new

DrawThread();

}

drawThread.start();

}

@Override

public

void

surfaceChanged(SurfaceHolder

holder,

int

format,

int

width,

int

height)

{

}

@Override

public

void

surfaceDestroyed(SurfaceHolder

holder)

{

if

(drawThread

!=

null)

{

drawThread.isRun

=

false;

drawThread

=

null;

}

}

class

DrawThread

extends

Thread

{

boolean

isRun

=

true;

@Override

public

void

run()

{

super.run();

/**绘制的线程

死循环

不断的跑动*/

while

(isRun)

{

Canvas

canvas

=

null;

try

{

synchronized

(surfaceHolder)

{

canvas

=

surfaceHolder.lockCanvas();

/**清除画面*/

canvas.drawColor(Color.TRANSPARENT,

PorterDuff.Mode.CLEAR);

boolean

isEnd

=

true;

/**对所有心进行遍历绘制*/

for

(int

i

=

0;

i

<

zanBeen.size();

i++)

{

isEnd

=

zanBeen.get(i).isEnd;

zanBeen.get(i).draw(canvas,

p);

}

/**这里做一个性能优化的动作，由于线程是死循环的

在没有心需要的绘制的时候会结束线程*/

if

(isEnd)

{

isRun

=

false;

drawThread

=

null;

}

}

}

catch

(Exception

e)

{

e.printStackTrace();

}

finally

{

if

(canvas

!=

null)

{

surfaceHolder.unlockCanvasAndPost(canvas);

}

}

try

{

/**用于控制绘制帧率*/

Thread.sleep(10);

}

catch

(InterruptedException

e)

{

e.printStackTrace();

}

}

}

}

public

void

stop()

{

if

(drawThread

!=

null)

{

//

for

(int

i

=

0;

i

<

zanBeen.size();

i++)

{

//

zanBeen.get(i).pause();

//

}

for

(int

i

=

0;

i

<

zanBeen.size();

i++)

{

zanBeen.get(i).stop();

}

drawThread.isRun

=

false;

drawT