Android實現(xiàn)錄音監(jiān)聽動畫的示例代碼
更新時間：2023年12月03日 10:24:11 作者：時光少年
在很多app種內(nèi)置了語音助手,也存在各種動畫,這篇文章主要為大家詳細介紹了Android實現(xiàn)錄音監(jiān)聽動畫的示例代碼,感興趣的小伙伴可以跟隨小編一起學習一下
一、前言
在很多app種內(nèi)置了語音助手，也存在各種動畫，主要原因是處理2個階段問題，第一個是監(jiān)聽聲音的等待效果，第二個是語意解析存在一定耗時的等待效果，前者要求有聲音輸入時有視覺反饋，后者讓用戶知道在處理某些事情，同時呢，這個效果還能互相切換，這是一般語音監(jiān)聽動畫的設計邏輯。本文提供一種，希望對大家有所幫助。
效果圖
（gif 有些卡，可能是壓縮的原因）
二、實現(xiàn)方法
2.1 過渡動畫
必須等待上一個動畫結束后再切換為制定狀態(tài)
2.2 聲音抖動計算
本文沒有明確計算線性音量，取出音量數(shù)據(jù)，進行了簡單的計算
public void updateShakeValue(int volume) {
if (this.getVisibility() != View.VISIBLE || !isAttachedToWindow()) return;
if (!isPlaying) return;
float ratio = volume * 1.0f / this.mMaxShakeRange;
if (ratio < 1f / 4) {
ratio = 0;
}
if (ratio >= 1f / 4 && ratio < 2f / 4) {
ratio = 1f / 4;
}
if (ratio >= 2f / 4 && ratio < 3f / 4) {
ratio = 2f / 4;
}
if (ratio >= 3f / 4) {
ratio = 1f;
}
updateShakeRatio(ratio);
}
2.3 模式切換
需要LISTENING和LOADING 模式之間互相切換
public void startPlay(final int state) {
post(new Runnable() {
@Override
public void run() {
setState(state);
if (!isPlaying) {
mCurrentState = mNextState;
}
isPlaying = true;
if (mNextState == mCurrentState) {
if (state == STATE_LISTENING) {
startListeningAnim();
} else if (state == STATE_LOADING) {
startLoadingAnim();
}
} else {
startTransformAnim();
}
}
});
}
#loading 效果
radarView.startPlay(SpeechRadarView.STATE_LOADING);
#listening效果
radarView.startPlay(SpeechRadarView.STATE_LISTENING);
#停止播放
radarView.stopPlay();
2.4 抖動幅度范圍，以適應不同類型的需求
#最大振幅 radarView.setMaxShakeRange(30); #當前值 radarView.updateShakeValue(20);
三、全部代碼
public class SpeechRadarView extends View {
private static final long ANIMATION_CIRCLE_TIMEOUT = 1000;
private static final long ANIMATION_LOADING_TIMEOUT = 800;
private ValueAnimator mShakeAnimatorTimer;
private int mFixedRadius = 0;
private int mMaxRadius = 0;
private TextPaint mPaint;
private AnimationCircle[] mAnimationCircle = new AnimationCircle[2];
private float mBullketStrokeWidthSize;
private AnimatorSet mAnimatorTimerSet = null;
private AnimatorSet mNextAnimatorTimerSet = null;
private ValueAnimator mTransformAnimatorTimer;
private int ANIMATION_MAIN_COLOR = 0x99FF8C14;
private static final int MAIN_COLOR = 0xFFFF8C14;
RectF arcBounds = new RectF();
LinearInterpolator linearInterpolator = new LinearInterpolator();
AccelerateDecelerateInterpolator accelerateDecelerateInterpolator = new AccelerateDecelerateInterpolator();
public static final int STATE_LOADING = 0;
public static final int STATE_LISTENING = 1;
private int mCurrentState = STATE_LOADING;
private int mNextState = STATE_LOADING; //過渡值
private float LOADING_STOKE_WIDTH = 0;
private int LOADING_START_ANGLE = 90;
private int mCurrentAngle = LOADING_START_ANGLE;
private int mTransformLoadingColor = Color.TRANSPARENT;
private int mTransformListeningColor = Color.TRANSPARENT;
private boolean isPlaying = false;
private float mShakeRatio = 0;
private float mNextShakeRatio = 0;
private long mStartShakeTime = 0;
private int mMaxShakeRange = 100;
public SpeechRadarView(Context context) {
this(context, null);
}
public SpeechRadarView(Context context, AttributeSet attrs) {
this(context, attrs, 0);
}
public SpeechRadarView(Context context, AttributeSet attrs, int defStyleAttr) {
super(context, attrs, defStyleAttr);
initPaint();
}
private void setState(int state) {
if (this.mNextState == state) {
return;
}
this.mNextState = state;
}
public int getState() {
return mNextState;
}
private void initPaint() {
// 實例化畫筆并打開抗鋸齒
mPaint = new TextPaint(Paint.ANTI_ALIAS_FLAG);
mPaint.setAntiAlias(true);
mPaint.setPathEffect(new CornerPathEffect(10)); //設置線條類型
mPaint.setStrokeWidth(dip2px(1));
mPaint.setTextSize(dip2px((12)));
mPaint.setStyle(Paint.Style.STROKE);
mBullketStrokeWidthSize = dip2px(5);
LOADING_STOKE_WIDTH = dip2px(5);
}
@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
super.onMeasure(widthMeasureSpec, heightMeasureSpec);
super.onMeasure(widthMeasureSpec, heightMeasureSpec);
int widthMode = MeasureSpec.getMode(widthMeasureSpec);
int width = MeasureSpec.getSize(widthMeasureSpec);
int heightMode = MeasureSpec.getMode(heightMeasureSpec);
int height = MeasureSpec.getSize(heightMeasureSpec);
if (widthMode != MeasureSpec.EXACTLY) {
width = (int) dip2px(210);
}
if (heightMode != MeasureSpec.EXACTLY) {
height = (int) dip2px(210);
}
setMeasuredDimension(width, height);
}
public float dip2px(float dp) {
return TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, dp, getResources().getDisplayMetrics());
}
@Override
protected void onDraw(Canvas canvas) {
super.onDraw(canvas);
int width = getWidth();
int height = getHeight();
if (width == 0 || height == 0) return;
int centerX = width / 2;
int centerY = height / 2;
int diameter = Math.min(width, height) / 2;
mFixedRadius = diameter / 3;
mMaxRadius = diameter;
initAnimationCircle();
if (!isInEditMode() && !isPlaying) return;
int layerId = saveLayer(canvas, centerX, centerY);
if (mNextState == mCurrentState) {
if (mCurrentState == STATE_LISTENING) {
drawAnimationCircle(canvas);
drawFixCircle(canvas, MAIN_COLOR);
drawFlashBullket(canvas, Color.WHITE, mShakeRatio);
mShakeRatio = 0;
} else if (mCurrentState == STATE_LOADING) {
drawLoadingArc(canvas, MAIN_COLOR);
drawFlashBullket(canvas, MAIN_COLOR, 0);
}
} else {
if (this.mNextState == STATE_LISTENING) {
drawLoadingArc(canvas, mTransformLoadingColor);
drawFixCircle(canvas, mTransformListeningColor);
drawFlashBullket(canvas, Color.WHITE, 0);
} else {
drawFixCircle(canvas, mTransformListeningColor);
drawLoadingArc(canvas, mTransformLoadingColor);
drawFlashBullket(canvas, MAIN_COLOR, 0);
}
}
restoreLayer(canvas, layerId);
}
private void drawLoadingArc(Canvas canvas, int color) {
int oldColor = mPaint.getColor();
Paint.Style style = mPaint.getStyle();
float strokeWidth = mPaint.getStrokeWidth();
mPaint.setStrokeWidth(LOADING_STOKE_WIDTH);
float innerOffset = LOADING_STOKE_WIDTH / 2;
mPaint.setColor(color);
mPaint.setStyle(Paint.Style.STROKE);
arcBounds.set(-mFixedRadius + innerOffset, -mFixedRadius + innerOffset, mFixedRadius - innerOffset, mFixedRadius - innerOffset);
canvas.drawArc(arcBounds, mCurrentAngle, 270, false, mPaint);
mPaint.setColor(oldColor);
mPaint.setStyle(style);
mPaint.setStrokeWidth(strokeWidth);
}
private void drawFlashBullket(Canvas canvas, int color, float fraction) {
int bullketZoneWidth = mFixedRadius;
int bullketZoneHeight = mFixedRadius * 2 / 3;
int minHeight = (int) (bullketZoneHeight / 3f);
int maxRangeHeight = (int) (bullketZoneHeight * 2 / 3f);
drawFlashBullket(canvas, bullketZoneWidth, color, minHeight, (maxRangeHeight * fraction));
}
private void drawFlashBullket(Canvas canvas, int width, int color, int height, float delta) {
int offset = (int) ((width - mBullketStrokeWidthSize * 4) / 3);
int oldColor = mPaint.getColor();
float strokeWidth = mPaint.getStrokeWidth();
if (delta < 0f) {
delta = 0f;
}
mPaint.setColor(color);
mPaint.setStrokeCap(Paint.Cap.ROUND);
mPaint.setStrokeWidth(mBullketStrokeWidthSize);
for (int i = 0; i < 4; i++) {
int startX = (int) (i * (offset + mBullketStrokeWidthSize) - width / 2 + mBullketStrokeWidthSize / 2);
if (i == 0 || i == 3) {
canvas.drawLine(startX, -height / 2F + delta * 1 / 3, startX, height / 2F + delta * 1 / 3, mPaint);
} else {
canvas.drawLine(startX, -(height / 2F + delta * 2 / 3), startX, (height / 2F + delta * 2 / 3), mPaint);
}
}
mPaint.setColor(oldColor);
mPaint.setStrokeWidth(strokeWidth);
}
@Override
protected void onSizeChanged(int w, int h, int oldw, int oldh) {
super.onSizeChanged(w, h, oldw, oldh);
}
private void drawAnimationCircle(Canvas canvas) {
for (int i = 0; i < mAnimationCircle.length; i++) {
AnimationCircle circle = mAnimationCircle[i];
if (circle.radius > mFixedRadius) {
drawCircle(canvas, circle.color, circle.radius);
Log.e("AnimationCircle", "i=" + i + " , radius=" + circle.radius);
} else {
Log.d("AnimationCircle", "i=" + i + " , radius=" + circle.radius);
}
}
}
private void initAnimationCircle() {
for (int i = 0; i < mAnimationCircle.length; i++) {
if (mAnimationCircle[i] == null) {
if (i == 0) {
mAnimationCircle[i] = new AnimationCircle(mMaxRadius, mFixedRadius, 0x88FF8C14);
} else {
mAnimationCircle[i] = new AnimationCircle(mMaxRadius, mFixedRadius, 0x99FF8C14);
}
} else {
if (mAnimationCircle[i].token != mMaxRadius) {
mAnimationCircle[i].radius = mFixedRadius;
mAnimationCircle[i].token = mMaxRadius;
}
}
}
}
private void drawCircle(Canvas canvas, int color, float radius) {
int oldColor = mPaint.getColor();
Paint.Style style = mPaint.getStyle();
float strokeWidth = mPaint.getStrokeWidth();
mPaint.setStrokeWidth(0);
mPaint.setColor(color);
mPaint.setStyle(Paint.Style.FILL);
canvas.drawCircle(0, 0, radius, mPaint);
mPaint.setColor(oldColor);
mPaint.setStyle(style);
mPaint.setStrokeWidth(strokeWidth);
}
private void restoreLayer(Canvas canvas, int save) {
canvas.restoreToCount(save);
}
private int saveLayer(Canvas canvas, int centerX, int centerY) {
int save = canvas.save();
canvas.translate(centerX, centerY);
return save;
}
private void drawFixCircle(Canvas canvas, int color) {
drawCircle(canvas, color, mFixedRadius);
}
public void startPlay(final int state) {
post(new Runnable() {
@Override
public void run() {
setState(state);
if (!isPlaying) {
mCurrentState = mNextState;
}
isPlaying = true;
if (mNextState == mCurrentState) {
if (state == STATE_LISTENING) {
startListeningAnim();
} else if (state == STATE_LOADING) {
startLoadingAnim();
}
} else {
startTransformAnim();
}
}
});
}
public void startLoadingAnim() {
if (mAnimatorTimerSet != null) {
mAnimatorTimerSet.cancel();
}
mAnimatorTimerSet = getAnimatorLoadingSet();
if (mAnimatorTimerSet != null) {
mAnimatorTimerSet.start();
}
}
private void startTransformAnim() {
if (mNextAnimatorTimerSet != null) {
mNextAnimatorTimerSet.cancel();
}
if (mTransformAnimatorTimer != null) {
mTransformAnimatorTimer.cancel();
}
mTransformAnimatorTimer = buildTransformAnimatorTimer(mCurrentState, mNextState);
if (mNextState == STATE_LISTENING) {
mNextAnimatorTimerSet = getAnimatorCircleSet();
} else {
mNextAnimatorTimerSet = getAnimatorLoadingSet();
}
if (mTransformAnimatorTimer != null) {
mTransformAnimatorTimer.start();
}
if (mNextAnimatorTimerSet != null) {
mNextAnimatorTimerSet.start();
}
}
public void startListeningAnim() {
if (mAnimatorTimerSet != null) {
mAnimatorTimerSet.cancel();
}
AnimatorSet animatorTimerSet = getAnimatorCircleSet();
if (animatorTimerSet == null) return;
mAnimatorTimerSet = animatorTimerSet;
mAnimatorTimerSet.start();
}
@Nullable
private AnimatorSet getAnimatorCircleSet() {
AnimatorSet animatorTimerSet = new AnimatorSet();
ValueAnimator firstAnimatorTimer = buildCircleAnimatorTimer(mAnimationCircle[0]);
ValueAnimator secondAnimatorTimer = buildCircleAnimatorTimer(mAnimationCircle[1]);
if (firstAnimatorTimer == null || secondAnimatorTimer == null) return null;
secondAnimatorTimer.setStartDelay(ANIMATION_CIRCLE_TIMEOUT / 2);
animatorTimerSet.playTogether(firstAnimatorTimer, secondAnimatorTimer);
return animatorTimerSet;
}
@Nullable
private AnimatorSet getAnimatorLoadingSet() {
ValueAnimator valueAnimator = buildLoadingAnimatorTimer();
if (valueAnimator == null) return null;
AnimatorSet animatorTimerSet = new AnimatorSet();
animatorTimerSet.play(valueAnimator);
return animatorTimerSet;
}
@Nullable
private ValueAnimator buildCircleAnimatorTimer(final AnimationCircle circle) {
if (mFixedRadius <= 0 || circle == null) return null;
ValueAnimator animatorTimer = ValueAnimator.ofFloat(mFixedRadius, Math.min(getWidth(),getHeight()) / 2F);
animatorTimer.setDuration(ANIMATION_CIRCLE_TIMEOUT);
animatorTimer.setRepeatCount(ValueAnimator.INFINITE);
animatorTimer.setInterpolator(linearInterpolator);
animatorTimer.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
@Override
public void onAnimationUpdate(ValueAnimator animation) {
float dx = (float) animation.getAnimatedValue();
float fraction = 1 - animation.getAnimatedFraction();
float radius = dx;
int color = argb((int) (Color.alpha(ANIMATION_MAIN_COLOR) * fraction), Color.red(ANIMATION_MAIN_COLOR), Color.green(ANIMATION_MAIN_COLOR), Color.blue(ANIMATION_MAIN_COLOR));
if (mCurrentState != mNextState) {
color = Color.TRANSPARENT;
}
if (circle.radius != radius || circle.color != color) {
circle.radius = radius;
circle.color = color;
postInvalidate();
}
}
});
return animatorTimer;
}
@Nullable
private ValueAnimator buildLoadingAnimatorTimer() {
if (mFixedRadius <= 0) return null;
ValueAnimator animatorTimer = ValueAnimator.ofFloat(0, 1);
animatorTimer.setDuration(ANIMATION_LOADING_TIMEOUT);
animatorTimer.setRepeatCount(ValueAnimator.INFINITE);
animatorTimer.setInterpolator(new AccelerateDecelerateInterpolator());
animatorTimer.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
@Override
public void onAnimationUpdate(ValueAnimator animation) {
float fraction = animation.getAnimatedFraction();
int angle = (int) (LOADING_START_ANGLE + fraction * 360);
if (mCurrentAngle != angle) {
mCurrentAngle = angle;
postInvalidate();
}
}
});
return animatorTimer;
}
@Nullable
private ValueAnimator buildTransformAnimatorTimer(final int currentState, final int nextState) {
if (mFixedRadius <= 0) return null;
final int alpha = Color.alpha(MAIN_COLOR);
final int red = Color.red(MAIN_COLOR);
final int green = Color.green(MAIN_COLOR);
final int blue = Color.blue(MAIN_COLOR);
ValueAnimator animatorTimer = ValueAnimator.ofFloat(currentState, nextState);
animatorTimer.setDuration(ANIMATION_LOADING_TIMEOUT);
animatorTimer.setInterpolator(accelerateDecelerateInterpolator);
animatorTimer.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
@Override
public void onAnimationUpdate(ValueAnimator animation) {
float animatedValue = (float) animation.getAnimatedValue();
if (mCurrentState != mNextState) {
mTransformListeningColor = argb((int) (alpha * animatedValue), red, green, blue);
mTransformLoadingColor = argb((int) (alpha * (1 - animatedValue)), red, green, blue);
Log.d("animatedValue", " --- >" + animatedValue);
postInvalidate();
}
}
});
animatorTimer.addListener(new AnimatorListenerAdapter() {
@Override
public void onAnimationEnd(Animator animation) {
super.onAnimationEnd(animation);
resetAnimationState();
}
@Override
public void onAnimationCancel(Animator animation) {
super.onAnimationCancel(animation);
resetAnimationState();
}
});
return animatorTimer;
}
private void resetAnimationState() {
mCurrentState = mNextState;
if (mAnimatorTimerSet != null) {
if (mAnimatorTimerSet != mNextAnimatorTimerSet) {
mAnimatorTimerSet.cancel();
}
}
mAnimatorTimerSet = mNextAnimatorTimerSet;
}
@Override
protected void onDetachedFromWindow() {
super.onDetachedFromWindow();
stopPlay();
}
public void stopPlay() {
isPlaying = false;
mCurrentAngle = LOADING_START_ANGLE;
try {
if (mAnimatorTimerSet != null) {
mAnimatorTimerSet.cancel();
}
if (mNextAnimatorTimerSet != null) {
mNextAnimatorTimerSet.cancel();
}
if (mShakeAnimatorTimer != null) {
mShakeAnimatorTimer.cancel();
}
} catch (Exception e) {
e.printStackTrace();
}
resetAnimationCircle();
postInvalidate();
}
private void resetAnimationCircle() {
for (AnimationCircle circle : mAnimationCircle) {
if (circle != null) {
circle.radius = mFixedRadius;
}
}
}
public static int argb(
@IntRange(from = 0, to = 255) int alpha,
@IntRange(from = 0, to = 255) int red,
@IntRange(from = 0, to = 255) int green,
@IntRange(from = 0, to = 255) int blue) {
return (alpha << 24) | (red << 16) | (green << 8) | blue;
}
public boolean isPlaying() {
return isPlaying;
}
private void updateShakeRatio(final float ratio) {
long currentTimeMillis = System.currentTimeMillis();
if (currentTimeMillis - mStartShakeTime >= 150) {
mNextShakeRatio = ratio;
if (mShakeRatio != mNextShakeRatio) {
startShakeAnimation();
}
mStartShakeTime = currentTimeMillis;
}
}
private void startShakeAnimation() {
if (mShakeAnimatorTimer != null) {
mShakeAnimatorTimer.cancel();
}
mShakeAnimatorTimer = ValueAnimator.ofFloat(mShakeRatio, mNextShakeRatio);
mShakeAnimatorTimer.setDuration(100);
mShakeAnimatorTimer.setInterpolator(accelerateDecelerateInterpolator);
mShakeAnimatorTimer.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
@Override
public void onAnimationUpdate(ValueAnimator animation) {
float ratio = (float) animation.getAnimatedValue();
if (mShakeRatio != ratio) {
mShakeRatio = ratio;
postInvalidate();
}
}
});
mShakeAnimatorTimer.start();
}
public void setMaxShakeRange(int maxShakeRange) {
this.mMaxShakeRange = maxShakeRange;
if (this.mMaxShakeRange <= 0) this.mMaxShakeRange = 100;
}
public void updateShakeValue(int volume) {
if (this.getVisibility() != View.VISIBLE || !isAttachedToWindow()) return;
if (!isPlaying) return;
float ratio = volume * 1.0f / this.mMaxShakeRange;
if (ratio < 1f / 4) {
ratio = 0;
}
if (ratio >= 1f / 4 && ratio < 2f / 4) {
ratio = 1f / 4;
}
if (ratio >= 2f / 4 && ratio < 3f / 4) {
ratio = 2f / 4;
}
if (ratio >= 3f / 4) {
ratio = 1f;
}
updateShakeRatio(ratio);
}
public boolean isAttachedToWindow() {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
return super.isAttachedToWindow();
} else {
return getWindowToken() != null;
}
}
private static class AnimationCircle {
private float radius;
private int color;
private int token;
AnimationCircle(int token, int radius, int color) {
this.radius = radius;
this.color = color;
this.token = token;
}
}
}
四、總結
總體上這個設計不是很難，難點是狀態(tài)切換的一些過渡設計，保證上一個動畫結束完成之后才能展示下一個動畫，其詞就是抖動邏輯，實際上也不是很復雜，第三方SDK的音量值一般都是有的，實時獲取就好了。
以上就是Android實現(xiàn)錄音監(jiān)聽動畫的示例代碼的詳細內(nèi)容，更多關于Android錄音監(jiān)聽動畫的資料請關注腳本之家其它相關文章！
相關文章
不管是在我們的布局還是在實現(xiàn)代碼中進行操控，我們的靈活性都不是局限于一個固定的數(shù)值，而是面對不同的手機對象都有一個適應的數(shù)值。2013-04-04
這篇文章主要介紹了安卓監(jiān)聽屏幕的橫豎翻轉實現(xiàn)方法，有需要的朋友可以參考一下2013-12-12
Retrofit 創(chuàng)建網(wǎng)絡請求接口實例過程
這篇文章主要為大家介紹了Retrofit 創(chuàng)建網(wǎng)絡請求接口實例過程詳解，有需要的朋友可以借鑒參考下，希望能夠有所幫助，祝大家多多進步，早日升職加薪2022-12-12
android 圖片操作(縮放移動) 實例代碼，需要的朋友可以參考一下2013-06-06
這篇文章主要為大家詳細介紹了Android原生嵌入React Native的相關資料,具有一定的參考價值，感興趣的小伙伴們可以參考一下2016-09-09
這篇文章主要介紹了Android 日期和時間的使用實例詳解的相關資料,需要的朋友可以參考下2016-12-12
Android入門之使用RecyclerView完美實現(xiàn)瀑布流界面詳解
網(wǎng)上充滿著不完善的基于RecyclerView的瀑布流實現(xiàn)，要么根本是錯的、要么就是只知其一不知其二。本文就來用RecyclerView完美實現(xiàn)瀑布流界面，希望大家有所幫助2023-02-02
Flutter 利用CustomScrollView實現(xiàn)滑動效果
我們可以使用ListView將幾個GridView組合在一起實現(xiàn)了不同可滑動組件的粘合，但是這里必須要設置禁止 GridView 的滑動，防止多個滑動組件的沖突。這種方式寫起來不太方便，事實上 Flutter 提供了 CustomScrollView 來粘合多個滑動組件，并且可以實現(xiàn)更有趣的滑動效果。2021-06-06
Android使用元數(shù)據(jù)實現(xiàn)配置信息的傳遞方法詳細介紹
這篇文章主要介紹了Android使用元數(shù)據(jù)實現(xiàn)配置信息的傳遞方法，也就是實現(xiàn)配置快捷菜單功能，文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值，需要的朋友們下面隨著小編來一起學習吧2022-09-09
RecyclerView嵌套RecyclerView滑動卡頓的解決方法
這篇文章主要為大家詳細介紹了RecyclerView嵌套RecyclerView滑動卡頓的解決方法，具有一定的參考價值，感興趣的小伙伴們可以參考一下2018-12-12