现在有不少的应用开始实现了摇一摇功能，今天就把摇一摇的实现过程做一下记录。
用到知识点
1.加速度传感器
2.补间动画
3.手机震动 (Vibrator)
4.较短 声音/音效 的播放 (SoundPool)
首先布局文件
布局写了好了就开始实现摇一摇功能了。
首先实现摇一摇的操作
public class ShakeListener implements SensorEventListener {
// 速度阈值，当摇晃速度达到这值后产生作用
private static final int SPEED_SHRESHOLD = 3000;
// 两次检测的时间间隔
private static final int UPTATE_INTERVAL_TIME = 70;
// 传感器管理器
private SensorManager sensorManager;
// 传感器
private Sensor sensor;
// 重力感应监听器
private OnShakeListenerCallBack onShakeListener;
// 上下文
private Context mContext;
// 手机上一个位置时重力感应坐标
private float lastX;
private float lastY;
private float lastZ;
// 上次检测时间
private long lastUpdateTime;
// 构造器
public ShakeListener(Context context) {
// 获得监听对象
mContext = context;
start();
}
/**开始重力传感器的检测*/
public void start() {
// 获得传感器管理器
sensorManager = (SensorManager) mContext.getSystemService(Context.SENSOR_SERVICE);
if (sensorManager != null) {
// 获得重力传感器
sensor = sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);
}
// 注册
if (sensor != null) {
sensorManager.registerListener(this, sensor, SensorManager.SENSOR_DELAY_GAME);
}
}
/**停止检测*/
public void stop() {
sensorManager.unregisterListener(this);
}
/**重力感应器感应获得变化数据*/
@Override
public void onSensorChanged(SensorEvent event) {
// 现在检测时间
long currentUpdateTime = System.currentTimeMillis();
// 两次检测的时间间隔
long timeInterval = currentUpdateTime - lastUpdateTime;
// 判断是否达到了检测时间间隔
if (timeInterval < UPTATE_INTERVAL_TIME)
return;
// 现在的时间变成last时间
lastUpdateTime = currentUpdateTime;
// 获得x,y,z坐标
float x = event.values[0];
float y = event.values[1];
float z = event.values[2];
// 获得x,y,z的变化值
float deltaX = x - lastX;
float deltaY = y - lastY;
float deltaZ = z - lastZ;
// 将现在的坐标变成last坐标
lastX = x;
lastY = y;
lastZ = z;
double speed = Math.sqrt(deltaX * deltaX + deltaY * deltaY + deltaZ * deltaZ) / timeInterval * 10000;
// 达到速度阀值，发出提示
if (speed >= SPEED_SHRESHOLD) {
onShakeListener.onShake();
}
}
@Override
public void onAccuracyChanged(Sensor sensor, int accuracy) {
}
/**摇晃监听接口*/
public interface OnShakeListenerCallBack {
public void onShake();
}
/**设置重力感应监听器*/
public void setOnShakeListener(OnShakeListenerCallBack listener) {
onShakeListener = listener;
}
}
首先获取SensorManager，进而获取到加速度传感器，再设置监听器。然后在监听中根据传感器数值的变化，根据需要做响应的处理。当达到要求时进行回调，进而实现摇一摇后响应的逻辑(音效、动画等)。
摇一摇完成后动画
/** 摇一摇手掌上部分动画 */
public AnimationSet getUpAnim(){
AnimationSet animationSet = new AnimationSet(true);
TranslateAnimation translateAnimation0 = new TranslateAnimation(Animation.RELATIVE_TO_SELF,0,Animation.RELATIVE_TO_SELF,0,Animation.RELATIVE_TO_SELF,0,Animation.RELATIVE_TO_SELF,-0.8f);
translateAnimation0.setDuration(OPEN_TIME);
translateAnimation0.setAnimationListener(openAnimationListner);//图片上移动画监听
TranslateAnimation translateAnimation1 = new TranslateAnimation(Animation.RELATIVE_TO_SELF,0,Animation.RELATIVE_TO_SELF,0,Animation.RELATIVE_TO_SELF,0,Animation.RELATIVE_TO_SELF,0.8f);
translateAnimation1.setDuration(CLOSE_TIME);
translateAnimation1.setAnimationListener(closeAnimationListener);//图片下移动画监听
translateAnimation1.setStartOffset(OFFSET_TIME);
translateAnimation1.setInterpolator(new AccelerateInterpolator(1));
animationSet.addAnimation(translateAnimation0);
animationSet.addAnimation(translateAnimation1);
return animationSet;
}
/** 摇一摇手掌下部分动画 */
public AnimationSet getDownAnim(){
AnimationSet animationSet = new AnimationSet(true);
TranslateAnimation translateAnimation0 = new TranslateAnimation(Animation.RELATIVE_TO_SELF,0,Animation.RELATIVE_TO_SELF,0,Animation.RELATIVE_TO_SELF,0,Animation.RELATIVE_TO_SELF,0.8f);
translateAnimation0.setDuration(OPEN_TIME);
translateAnimation0.setAnimationListener(openAnimationListner);//图片上移动画监听
TranslateAnimation translateAnimation1 = new TranslateAnimation(Animation.RELATIVE_TO_SELF,0,Animation.RELATIVE_TO_SELF,0,Animation.RELATIVE_TO_SELF,0,Animation.RELATIVE_TO_SELF,-0.8f);
translateAnimation1.setDuration(CLOSE_TIME);
translateAnimation1.setAnimationListener(closeAnimationListener);//图片下移动画监听
translateAnimation1.setStartOffset(OFFSET_TIME);
translateAnimation1.setInterpolator(new AccelerateInterpolator(1));
animationSet.addAnimation(translateAnimation0);
animationSet.addAnimation(translateAnimation1);
return animationSet;
}
/** 显示摇出结果动画 */
public Animation getReusltAnim(){
TranslateAnimation translateAnimation = new TranslateAnimation(Animation.RELATIVE_TO_SELF,0,Animation.RELATIVE_TO_SELF,0,Animation.RELATIVE_TO_SELF,-1,Animation.RELATIVE_TO_SELF,0);
translateAnimation.setDuration(OPEN_TIME);
translateAnimation.setAnimationListener(new Animation.AnimationListener() {
@Override
public void onAnimationStart(Animation animation) {
}
@Override
public void onAnimationEnd(Animation animation) {
if (mDoAnimationListener != null) {
mDoAnimationListener.onAnimEnd(SHAKE_RESULT_VISIBLE_CODE );
}
}
@Override
public void onAnimationRepeat(Animation animation) {
}
});
return translateAnimation;
}
/** 隐藏摇出结果动画 */
public Animation getReusltGoneAnim(){
TranslateAnimation translateAnimation = new TranslateAnimation(Animation.RELATIVE_TO_SELF,0,Animation.RELATIVE_TO_SELF,0,Animation.RELATIVE_TO_SELF,0,Animation.RELATIVE_TO_SELF,3);
translateAnimation.setDuration(OPEN_TIME);
translateAnimation.setAnimationListener(new Animation.AnimationListener() {
@Override
public void onAnimationStart(Animation animation) {
}
@Override
public void onAnimationEnd(Animation animation) {
if (mDoAnimationListener != null) {
mDoAnimationListener.onAnimEnd(SHAKE_RESULT_GONE_CODE);
}
}
@Override
public void onAnimationRepeat(Animation animation) {
}
});
return translateAnimation;
}
/**手掌图开启动画监听*/
public Animation.AnimationListener openAnimationListner = new Animation.AnimationListener() {
@Override
public void onAnimationStart(Animation animation) {
//动画开始执行时回调
if (mDoAnimationListener != null) {
mDoAnimationListener.onAnimStart(OPEN_ANIM_CODE);
}
}
@Override
public void onAnimationEnd(Animation animation) {
}
@Override
public void onAnimationRepeat(Animation animation) {
}
};
/**手掌图合上动画监听*/
public Animation.AnimationListener closeAnimationListener = new Animation.AnimationListener() {
@Override
public void onAnimationStart(Animation animation) {
}
@Override
public void onAnimationEnd(Animation animation) {
//动画结束时回调
if (mDoAnimationListener != null) {
mDoAnimationListener.onAnimEnd(COLSE_ANIM_CODE);
}
}
@Override
public void onAnimationRepeat(Animation animation) {
}
};
public interface DoAnimationListener{
void onAnimStart(int code);
void onAnimEnd(int code);
}
震动
震动首先要加权限
震动代码
Vibrator vibrator = (Vibrator) getSystemService(VIBRATOR_SERVICE);
vibrator.vibrate(500);
接下来就是播放音效了
public class Sound {
private static Sound mInstance;
private SoundPool mSoundPool;//音效池
private HashMap mSoundPoolMap;//定义一个HashMap用于存放音频流的ID
public static Sound getInstance() {
if (mInstance == null) {
mInstance = new Sound();
}
return mInstance;
}
/**初始化音效池---向音效池添加音效*/
public void initPool(final Context context){
mSoundPoolMap = new HashMap<>();
mSoundPool = new SoundPool(3, AudioManager.STREAM_ALARM,1);
if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.LOLLIPOP) {
AudioAttributes audioAttributes = null;
audioAttributes = new AudioAttributes.Builder()
.setUsage(AudioAttributes.USAGE_ALARM)
.setContentType(AudioAttributes.CONTENT_TYPE_MUSIC)
.build();
mSoundPool = new SoundPool.Builder()
.setMaxStreams(3)
.setAudioAttributes(audioAttributes)
.build();
} else { // 5.0 以前
mSoundPool = new SoundPool(3, AudioManager.STREAM_ALARM, 0); // 创建SoundPool
}
new Thread(new Runnable() {
@Override
public void run() {
mSoundPoolMap.put(0,mSoundPool.load(context.getResources().openRawResourceFd(R.raw.shake_sound_male),1));
mSoundPoolMap.put(1,mSoundPool.load(context.getResources().openRawResourceFd(R.raw.shake_match),1));
mSoundPoolMap.put(2,mSoundPool.load(context.getResources().openRawResourceFd(R.raw.shake_nomatch),1));
}
}).start();
}
/** 播放摇一摇开始声音 */
public void playStartSound(){
try {
mSoundPool.play(mSoundPoolMap.get(0),1,1,0,0,1.3f);
} catch (Exception e) {
e.printStackTrace();
}
}
/** 播放摇一摇结束声音 */
public void playEndSound(){
try {
mSoundPool.play(mSoundPoolMap.get(1),1,1,0,0,1.0f);
} catch (Exception e) {
e.printStackTrace();
}
}
/** 什么都没摇到 */
public void playNotingSound(){
try {
mSoundPool.play(mSoundPoolMap.get(2),1,1,0,0,1.0f);
} catch (Exception e) {
e.printStackTrace();
}
}
}
首先定义一个音效池，一个HashMap存放音效id，然后向音效池中添加音效，在合适的时机播放对应的音效。
以上几个步骤实现整个摇一摇效果
最终代码
动画部分
public class ShakeAnimation{
/**展开动画*/
public static final long OPEN_TIME = 500;
/**关合动画*/
public static final long CLOSE_TIME = 280;
/**开合动画间隔*/
public static final long OFFSET_TIME = 800;
/**模拟延迟*/
public static final long SIMULLATE_DELAY = 400;
public static final int OPEN_ANIM_CODE = 1;
public static final int COLSE_ANIM_CODE = 2;
public static final int SHAKE_RESULT_GONE_CODE = 3;
public static final int SHAKE_RESULT_VISIBLE_CODE = 4;
private static DoAnimationListener mDoAnimationListener;
private static ShakeAnimation needForAnim;
public static ShakeAnimation getInstance(DoAnimationListener doAnimationListener) {
mDoAnimationListener = doAnimationListener;
if (needForAnim == null) {
needForAnim = new ShakeAnimation();
}
return needForAnim;
}
/** 摇一摇手掌上部分动画 */
public AnimationSet getUpAnim(){
AnimationSet animationSet = new AnimationSet(true);
TranslateAnimation translateAnimation0 = new TranslateAnimation(Animation.RELATIVE_TO_SELF,0,Animation.RELATIVE_TO_SELF,0,Animation.RELATIVE_TO_SELF,0,Animation.RELATIVE_TO_SELF,-0.8f);
translateAnimation0.setDuration(OPEN_TIME);
translateAnimation0.setAnimationListener(openAnimationListner);//图片上移动画监听
TranslateAnimation translateAnimation1 = new TranslateAnimation(Animation.RELATIVE_TO_SELF,0,Animation.RELATIVE_TO_SELF,0,Animation.RELATIVE_TO_SELF,0,Animation.RELATIVE_TO_SELF,0.8f);
translateAnimation1.setDuration(CLOSE_TIME);
translateAnimation1.setAnimationListener(closeAnimationListener);//图片下移动画监听
translateAnimation1.setStartOffset(OFFSET_TIME);
translateAnimation1.setInterpolator(new AccelerateInterpolator(1));
animationSet.addAnimation(translateAnimation0);
animationSet.addAnimation(translateAnimation1);
return animationSet;
}
/** 摇一摇手掌下部分动画 */
public AnimationSet getDownAnim(){
AnimationSet animationSet = new AnimationSet(true);
TranslateAnimation translateAnimation0 = new TranslateAnimation(Animation.RELATIVE_TO_SELF,0,Animation.RELATIVE_TO_SELF,0,Animation.RELATIVE_TO_SELF,0,Animation.RELATIVE_TO_SELF,0.8f);
translateAnimation0.setDuration(OPEN_TIME);
translateAnimation0.setAnimationListener(openAnimationListner);//图片上移动画监听
TranslateAnimation translateAnimation1 = new TranslateAnimation(Animation.RELATIVE_TO_SELF,0,Animation.RELATIVE_TO_SELF,0,Animation.RELATIVE_TO_SELF,0,Animation.RELATIVE_TO_SELF,-0.8f);
translateAnimation1.setDuration(CLOSE_TIME);
translateAnimation1.setAnimationListener(closeAnimationListener);//图片下移动画监听
translateAnimation1.setStartOffset(OFFSET_TIME);
translateAnimation1.setInterpolator(new AccelerateInterpolator(1));
animationSet.addAnimation(translateAnimation0);
animationSet.addAnimation(translateAnimation1);
return animationSet;
}
/** 显示摇出结果动画 */
public Animation getReusltAnim(){
TranslateAnimation translateAnimation = new TranslateAnimation(Animation.RELATIVE_TO_SELF,0,Animation.RELATIVE_TO_SELF,0,Animation.RELATIVE_TO_SELF,-1,Animation.RELATIVE_TO_SELF,0);
translateAnimation.setDuration(OPEN_TIME);
translateAnimation.setAnimationListener(new Animation.AnimationListener() {
@Override
public void onAnimationStart(Animation animation) {
}
@Override
public void onAnimationEnd(Animation animation) {
if (mDoAnimationListener != null) {
mDoAnimationListener.onAnimEnd(SHAKE_RESULT_VISIBLE_CODE );
}
}
@Override
public void onAnimationRepeat(Animation animation) {
}
});
return translateAnimation;
}
/** 隐藏摇出结果动画 */
public Animation getReusltGoneAnim(){
TranslateAnimation translateAnimation = new TranslateAnimation(Animation.RELATIVE_TO_SELF,0,Animation.RELATIVE_TO_SELF,0,Animation.RELATIVE_TO_SELF,0,Animation.RELATIVE_TO_SELF,3);
translateAnimation.setDuration(OPEN_TIME);
translateAnimation.setAnimationListener(new Animation.AnimationListener() {
@Override
public void onAnimationStart(Animation animation) {
}
@Override
public void onAnimationEnd(Animation animation) {
if (mDoAnimationListener != null) {
mDoAnimationListener.onAnimEnd(SHAKE_RESULT_GONE_CODE);
}
}
@Override
public void onAnimationRepeat(Animation animation) {
}
});
return translateAnimation;
}
/**手掌图开启动画监听*/
public Animation.AnimationListener openAnimationListner = new Animation.AnimationListener() {
@Override
public void onAnimationStart(Animation animation) {
//动画开始执行时回调
if (mDoAnimationListener != null) {
mDoAnimationListener.onAnimStart(OPEN_ANIM_CODE);
}
}
@Override
public void onAnimationEnd(Animation animation) {
}
@Override
public void onAnimationRepeat(Animation animation) {
}
};
/**手掌图合上动画监听*/
public Animation.AnimationListener closeAnimationListener = new Animation.AnimationListener() {
@Override
public void onAnimationStart(Animation animation) {
}
@Override
public void onAnimationEnd(Animation animation) {
//动画结束时回调
if (mDoAnimationListener != null) {
mDoAnimationListener.onAnimEnd(COLSE_ANIM_CODE);
}
}
@Override
public void onAnimationRepeat(Animation animation) {
}
};
public interface DoAnimationListener{
void onAnimStart(int code);
void onAnimEnd(int code);
}
}
音效部分
public class Sound {
private static Sound mInstance;
private SoundPool mSoundPool;//音效池
private HashMap mSoundPoolMap;//定义一个HashMap用于存放音频流的ID
public static Sound getInstance() {
if (mInstance == null) {
mInstance = new Sound();
}
return mInstance;
}
/**初始化音效池---向音效池添加音效*/
public void initPool(final Context context){
mSoundPoolMap = new HashMap<>();
mSoundPool = new SoundPool(3, AudioManager.STREAM_ALARM,1);
if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.LOLLIPOP) {
AudioAttributes audioAttributes = null;
audioAttributes = new AudioAttributes.Builder()
.setUsage(AudioAttributes.USAGE_ALARM)
.setContentType(AudioAttributes.CONTENT_TYPE_MUSIC)
.build();
mSoundPool = new SoundPool.Builder()
.setMaxStreams(3)
.setAudioAttributes(audioAttributes)
.build();
} else { // 5.0 以前
mSoundPool = new SoundPool(3, AudioManager.STREAM_ALARM, 0); // 创建SoundPool
}
new Thread(new Runnable() {
@Override
public void run() {
mSoundPoolMap.put(0,mSoundPool.load(context.getResources().openRawResourceFd(R.raw.shake_sound_male),1));
mSoundPoolMap.put(1,mSoundPool.load(context.getResources().openRawResourceFd(R.raw.shake_match),1));
mSoundPoolMap.put(2,mSoundPool.load(context.getResources().openRawResourceFd(R.raw.shake_nomatch),1));
}
}).start();
}
/** 播放摇一摇开始声音 */
public void playStartSound(){
try {
mSoundPool.play(mSoundPoolMap.get(0),1,1,0,0,1.3f);
} catch (Exception e) {
e.printStackTrace();
}
}
/** 播放摇一摇结束声音 */
public void playEndSound(){
try {
mSoundPool.play(mSoundPoolMap.get(1),1,1,0,0,1.0f);
} catch (Exception e) {
e.printStackTrace();
}
}
/** 什么都没摇到 */
public void playNotingSound(){
try {
mSoundPool.play(mSoundPoolMap.get(2),1,1,0,0,1.0f);
} catch (Exception e) {
e.printStackTrace();
}
}
}
重力传感器部分
public class ShakeListener implements SensorEventListener {
// 速度阈值，当摇晃速度达到这值后产生作用
private static final int SPEED_SHRESHOLD = 3000;
// 两次检测的时间间隔
private static final int UPTATE_INTERVAL_TIME = 70;
// 传感器管理器
private SensorManager sensorManager;
// 传感器
private Sensor sensor;
// 重力感应监听器
private OnShakeListenerCallBack onShakeListener;
// 上下文
private Context mContext;
// 手机上一个位置时重力感应坐标
private float lastX;
private float lastY;
private float lastZ;
// 上次检测时间
private long lastUpdateTime;
// 构造器
public ShakeListener(Context context) {
// 获得监听对象
mContext = context;
start();
}
/**开始重力传感器的检测*/
public void start() {
// 获得传感器管理器
sensorManager = (SensorManager) mContext.getSystemService(Context.SENSOR_SERVICE);
if (sensorManager != null) {
// 获得重力传感器
sensor = sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);
}
// 注册
if (sensor != null) {
sensorManager.registerListener(this, sensor, SensorManager.SENSOR_DELAY_GAME);
}
}
/**停止检测*/
public void stop() {
sensorManager.unregisterListener(this);
}
/**重力感应器感应获得变化数据*/
@Override
public void onSensorChanged(SensorEvent event) {
// 现在检测时间
long currentUpdateTime = System.currentTimeMillis();
// 两次检测的时间间隔
long timeInterval = currentUpdateTime - lastUpdateTime;
// 判断是否达到了检测时间间隔
if (timeInterval < UPTATE_INTERVAL_TIME)
return;
// 现在的时间变成last时间
lastUpdateTime = currentUpdateTime;
// 获得x,y,z坐标
float x = event.values[0];
float y = event.values[1];
float z = event.values[2];
// 获得x,y,z的变化值
float deltaX = x - lastX;
float deltaY = y - lastY;
float deltaZ = z - lastZ;
// 将现在的坐标变成last坐标
lastX = x;
lastY = y;
lastZ = z;
double speed = Math.sqrt(deltaX * deltaX + deltaY * deltaY + deltaZ * deltaZ) / timeInterval * 10000;
// 达到速度阀值，发出提示
if (speed >= SPEED_SHRESHOLD) {
// ToastUtils.showToast(mContext,"速度"+speed);
onShakeListener.onShake();
}
}
@Override
public void onAccuracyChanged(Sensor sensor, int accuracy) {
}
/**摇晃监听接口*/
public interface OnShakeListenerCallBack {
public void onShake();
}
/**设置重力感应监听器*/
public void setOnShakeListener(OnShakeListenerCallBack listener) {
onShakeListener = listener;
}
}
Activity部分
public class BActivity extends AppCompatActivity implements ShakeAnimation.DoAnimationListener {
@BindView(R.id.shake_flower)
ImageView mShakeFlower;
@BindView(R.id.shake_loading)
LinearLayout mShakeLoading;
@BindView(R.id.shake_result_img)
ImageView mShakeResultImg;
@BindView(R.id.shake_result_txt_name)
TextView mShakeResultTxtName;
@BindView(R.id.shake_result_txt_value)
TextView mShakeResultTxtValue;
@BindView(R.id.shake_result_layout)
RelativeLayout mShakeResultLayout;
@BindView(R.id.shakeImgUp_line)
LinearLayout mShakeImgUpLine;
@BindView(R.id.shakeImgUp)
RelativeLayout mShakeImgUp;
@BindView(R.id.shakeImgDown_line)
LinearLayout mShakeImgDownLine;
@BindView(R.id.shakeImgDown)
RelativeLayout mShakeImgDown;
private ShakeListener mShakeListener;
private ShakeAnimation mShakeAnimation;
private boolean hasReslut = false;
private int shakeNum = 0;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.shake_root);
ButterKnife.bind(this);
setResultVisible(false);//初始时不显示结果
showShakeLoading(false);//初始时不显示加载
initShake();
}
private void initShake() {
Sound.getInstance().initPool(this);
mShakeListener = new ShakeListener(this);
mShakeListener.setOnShakeListener(new ShakeListener.OnShakeListenerCallBack() {
@Override
public void onShake() {
startShake();//开始执行动画
mShakeListener.stop();//取消摇动监听,动画结束之前不再监听
vibrate(500);
Sound.getInstance().playStartSound();
}
});
}
/**
* 执行动画
*/
private void startShake() {
mShakeAnimation = ShakeAnimation.getInstance(this);
mShakeImgDown.startAnimation(mShakeAnimation.getDownAnim());
mShakeImgUp.startAnimation(mShakeAnimation.getUpAnim());
if (mShakeResultLayout != null && mShakeResultLayout.getVisibility() == View.VISIBLE) {
showResultGoneAnim();
}
}
/**
* 摇出的结果显示控制
*/
private void setResultVisible(boolean isVisible) {
if (mShakeResultLayout == null) {
return;
}
if (isVisible) {
mShakeResultLayout.setVisibility(View.VISIBLE);
} else {
mShakeResultLayout.setVisibility(View.INVISIBLE);
}
}
/**
* 正在加载
*/
private void showShakeLoading(boolean isShow) {
if (mShakeLoading == null) {
return;
}
if (isShow) {
mShakeLoading.setVisibility(View.VISIBLE);
} else {
mShakeLoading.setVisibility(View.GONE);
}
}
private void setResultView(){
showResultAnim();
if(!hasReslut){
mShakeResultImg.setImageResource(R.drawable.icon_sad_black);
mShakeResultTxtName.setText("什么都没摇到");
mShakeResultTxtValue.setVisibility(View.GONE);
}else {
mShakeResultImg.setImageResource(R.drawable.a);
mShakeResultTxtName.setText("浑水摸鱼");
mShakeResultTxtValue.setVisibility(View.VISIBLE);
mShakeResultTxtValue.setText("距离10公里");
}
playResultSound();
}
private void playResultSound(){
if(hasReslut){
Sound.getInstance().playEndSound();
}else {
Sound.getInstance().playNotingSound();
}
shakeNum++;
if(shakeNum%6==0){
hasReslut = !hasReslut;
}
}
/**
* 动画开启
*/
@Override
public void onAnimStart(int code) {
switch (code) {
case ShakeAnimation.OPEN_ANIM_CODE:
setHandLineVisible(true);
break;
}
}
/**
* 动画结束
*/
@Override
public void onAnimEnd(int code) {
switch (code) {
case ShakeAnimation.COLSE_ANIM_CODE:
setHandLineVisible(false);//
setResultView();
//showResultAnim();//显示结果
setResultVisible(true);
break;
case ShakeAnimation.SHAKE_RESULT_GONE_CODE:
setResultVisible(false);
break;
case ShakeAnimation.SHAKE_RESULT_VISIBLE_CODE:
mShakeListener.start();//动画结束了，重新开始监听摇动
break;
}
}
/**
* 手掌边线显示控制
*/
private void setHandLineVisible(boolean isVisible) {
if (mShakeImgUpLine != null) {
if (isVisible) {
mShakeImgUpLine.setVisibility(View.VISIBLE);
} else {
mShakeImgUpLine.setVisibility(View.GONE);
}
}
if (mShakeImgDownLine != null) {
if (isVisible) {
mShakeImgDownLine.setVisibility(View.VISIBLE);
} else {
mShakeImgDownLine.setVisibility(View.GONE);
}
}
}
/**显示结果动画*/
private void showResultAnim() {
if (mShakeAnimation != null) {
mShakeResultLayout.setAnimation(mShakeAnimation.getReusltAnim());
}
}
/**显示结果隐藏的动画*/
private void showResultGoneAnim(){
if (mShakeAnimation != null) {
mShakeResultLayout.setAnimation(mShakeAnimation.getReusltGoneAnim());
}
}
/**震动*/
private void vibrate(long milliseconds){
Vibrator vibrator = (Vibrator) getSystemService(VIBRATOR_SERVICE);
vibrator.vibrate(500);
}
@Override
public void onResume() {
super.onResume();
mShakeListener.start();
}
@Override
public void onPause() {
mShakeListener.stop();
super.onPause();
}
@Override
public void onStop() {
mShakeListener.stop();
super.onStop();
}
}
代码就写到这块了，基本实现了仿微信摇一摇功能。
参考：https://www.cnblogs.com/wangyuehome/p/4608128.html