• 玩转Android之加速度传感器的使用，模仿微信摇一摇

    Android系统带的传感器有很多种，最常见的莫过于微信的摇一摇了，那么今天我们就来看看Anroid中传感器的使用，做一个类似于微信摇一摇的效果。

    OK ,废话不多说，我们就先来看看效果图吧：

    当我摇动手机的时候这里的动画效果基本和微信上的动画效果一致，这里请大家自行脑补微信摇一摇画面。

    那我们就动手吧。

    1.布局文件

    好，那我们先来看看布局文件吧，在布局文件的正中央是一个花的图片，上图大家看到的手机图片实际上是两张图片拼接在一起，将花的那张图片遮住了，当摇一摇的时候，这两张图片分别向上或者向下移动，然后花的图片就可以显示出来。OK，基本原理就是这样，我们来看看代码：

    [java] view plain copy print?
    1. <?xml version="1.0" encoding="utf-8"?>  
    2. <RelativeLayout  
    3.     xmlns:android="http://schemas.android.com/apk/res/android"  
    4.     xmlns:tools="http://schemas.android.com/tools"  
    5.     android:layout_width="match_parent"  
    6.     android:layout_height="match_parent"  
    7.     android:background="#1f1f1f">  
    8.   
    9.     <ImageView  
    10.         android:layout_width="wrap_content"  
    11.         android:layout_height="wrap_content"  
    12.         android:src="@drawable/flower"/>  
    13.   
    14.     <LinearLayout  
    15.         android:layout_width="wrap_content"  
    16.         android:layout_height="wrap_content"  
    17.         android:layout_centerInParent="true"  
    18.         android:orientation="vertical">  
    19.   
    20.         <ImageView  
    21.             android:id="@+id/up"  
    22.             android:layout_width="wrap_content"  
    23.             android:layout_height="wrap_content"  
    24.             android:src="@drawable/up"/>  
    25.   
    26.         <ImageView  
    27.             android:id="@+id/down"  
    28.             android:layout_width="wrap_content"  
    29.             android:layout_height="wrap_content"  
    30.             android:src="@drawable/down"/>  
    31.     </LinearLayout>  
    32. </RelativeLayout>  



    2.传感器监听手机晃动

    既然要监听手机加速度的变化，那我首先需要获取系统的传感器：

    [java] view plain copy print?
    1. //获取到一个传感器管理器  
    2.         sensorManager = (SensorManager) getSystemService(SENSOR_SERVICE);  
    3.         //获得一个加速度传感器  
    4.         Sensor sensor = sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);  

    这两行代码首先是获取一个传感器管理器，然后获取加速度传感器，因为关于传感器的API 有很多，这里你需要指明自己要获取的是哪一个传感器。拿到传感器之后，需要注册监听，如下：
    [java] view plain copy print?
    1. sensorManager.registerListener(listener, sensor, SensorManager.SENSOR_DELAY_GAME);  

    注册传感器的监听一共需要三个参数，第一个是监听器，第二个是加速度传感器，第三个是传感器的灵敏度，传感器的灵敏度一共分为四级，如下，从上往下灵敏度依次降低： 
        1. SENSOR_DELAY_FASTEST
   2. SENSOR_DELAY_GAME
   3. SENSOR_DELAY_UI
   4. SENSOR_DELAY_NORMAL

    OK ，注册完之后，我们还是来看看这个监听器是什么吧：

    [java] view plain copy print?
    1. private SensorEventListener listener = new SensorEventListener() {  
    2.         //当手机的加速度发生变化时调用  
    3.         @Override  
    4.         public void onSensorChanged(SensorEvent event) {  
    5.             //获取手机在不同方向上加速度的变化  
    6.             float valuesX = Math.abs(event.values[0]);  
    7.             float valuesY = Math.abs(event.values[1]);  
    8.             float valuesZ = Math.abs(event.values[2]);  
    9.   
    10.             if (valuesX > 17 || valuesY > 17 || valuesZ > 17) {  
    11.                 startAnimation();  
    12.                 playSound();  
    13.             }  
    14.         }  
    15.   
    16.         @Override  
    17.         public void onAccuracyChanged(Sensor sensor, int accuracy) {  
    18.   
    19.         }  
    20.     };  

    这个listener中一共就两个方法，一个是当手机的加速度发生改变的时候调用，还有一个是当传感器的灵敏度发生改变的时候调用，当手机的加速度发生改变的时候，我们可以获取到手机在X 、Y、Z 三个维度上的变化值，拿到这个值之后，我们只需要进行简单的比较即可，如果有任意一个方向的值大于17，则认为有人在晃动手机，这个时候开启动画和声音的播放。

    3.开启动画和声音

    动画实际上就是两个平移动画，我们来看看：

    [java] view plain copy print?
    1. private void startAnimation() {  
    2.     //如果两次晃动手机的时间小于1秒，则只执行一次动画  
    3.     long currentTimeMillis = System.currentTimeMillis();  
    4.     if (currentTimeMillis - lastTime < 1000) {  
    5.         return;  
    6.     }  
    7.     lastTime = currentTimeMillis;  
    8.     AnimationSet upSet = new AnimationSet(true);  
    9.     TranslateAnimation upUp = new TranslateAnimation(TranslateAnimation.RELATIVE_TO_SELF, 0, TranslateAnimation.RELATIVE_TO_SELF,  
    10.             0, TranslateAnimation.RELATIVE_TO_SELF, 0, TranslateAnimation.RELATIVE_TO_SELF, -1);  
    11.     upUp.setDuration(1000);  
    12.     TranslateAnimation upDown = new TranslateAnimation(TranslateAnimation.RELATIVE_TO_SELF, 0, TranslateAnimation.RELATIVE_TO_SELF,  
    13.             0, TranslateAnimation.RELATIVE_TO_SELF, 0, TranslateAnimation.RELATIVE_TO_SELF, 1);  
    14.     upDown.setDuration(1000);  
    15.     upDown.setStartOffset(1000);  
    16.     upSet.addAnimation(upUp);  
    17.     upSet.addAnimation(upDown);  
    18.     up.startAnimation(upSet);  
    19.     AnimationSet downSet = new AnimationSet(true);  
    20.     TranslateAnimation downUp = new TranslateAnimation(TranslateAnimation.RELATIVE_TO_SELF, 0, TranslateAnimation.RELATIVE_TO_SELF,  
    21.             0, TranslateAnimation.RELATIVE_TO_SELF, 0, TranslateAnimation.RELATIVE_TO_SELF, 1);  
    22.     downUp.setDuration(1000);  
    23.     TranslateAnimation downDown = new TranslateAnimation(TranslateAnimation.RELATIVE_TO_SELF, 0, TranslateAnimation.RELATIVE_TO_SELF,  
    24.             0, TranslateAnimation.RELATIVE_TO_SELF, 0, TranslateAnimation.RELATIVE_TO_SELF, -1);  
    25.     downDown.setDuration(1000);  
    26.     downDown.setStartOffset(1000);  
    27.     downSet.addAnimation(downUp);  
    28.     downSet.addAnimation(downDown);  
    29.     down.startAnimation(downSet);  
    30. }  

    至于声音，由于我这里只是播放比较短小的音效而已，所以并没有必要使用MediaPlayer，我可以通过一个声音池来解决这个问题，代码如下:
    [java] view plain copy print?
    1. /** 
    2.  * 初始化声音池 
    3.  */  
    4. private void initSoundPool() {  
    5.     if (Build.VERSION.SDK_INT > 20) {  
    6.         SoundPool.Builder builder = new SoundPool.Builder();  
    7.         //1.最大并发流数  
    8.         builder.setMaxStreams(3);  
    9.         AudioAttributes.Builder aaBuilder = new AudioAttributes.Builder();  
    10.         aaBuilder.setLegacyStreamType(AudioManager.STREAM_MUSIC);  
    11.         builder.setAudioAttributes(aaBuilder.build());  
    12.         soundPool = builder.build();  
    13.     } else {  
    14.         soundPool = new SoundPool(3, AudioManager.STREAM_MUSIC, 0);  
    15.     }  
    16.     //加载一个音频文件  
    17.     sound1 = soundPool.load(this, R.raw.awe, 1);  
    18. }  

    在创建一个声音池的时候我采取了两种不同的方案，如果系统的版本大于20，则是用第一种方式获取声音池，否则使用第二种方式获取声音池。获取声音池之后，再通过声音池加载一个音频文件。加载完成之后，我就可以对这个音频文件进行播放了，如下：
    [java] view plain copy print?
    1. //1.声音的id  
    2. //2.3.表示左右声道的音量  
    3. //4.优先级  
    4. //5.是否循环  
    5. //6.声音播放速率  
    6. soundPool.play(sound1, 1, 1, 0, 0, 1);  

    每个参数的含义都写的很清楚了，大家又不清楚的地方可以直接看源码，这里的源码注释很好懂。

    最后一步就是开启手机震动了，开启手机震动，我需要首先获取震动服务，如下：

    [java] view plain copy print?
    1. //获取手机震动服务  
    2.        vibrator = (Vibrator) getSystemService(VIBRATOR_SERVICE);  

    然后调用Vibrator类中的vibrator方法执行震动，如下：
    [java] view plain copy print?
    1. //1.表示震动的节奏off/on/off/on/off/on......  
    2.         //2.表示是否重复震动，-1表示不重复  
    3.         vibrator.vibrate(new long[]{100, 200, 100, 200, 100, 200}, -1);  

    手机震动一定要记得添加震动权限哦，如下：
    [java] view plain copy print?
    1. <uses-permission android:name="android.permission.VIBRATE" />  

    OK ，最后，在销毁Activity的时候要解除对传感器的监听，同时释放声音池资源，如下：
    [java] view plain copy print?
    1. @Override  
    2. protected void onDestroy() {  
    3.     super.onDestroy();  
    4.     //解除对加速度传感器的监听  
    5.     sensorManager.unregisterListener(listener);  
    6.     if (soundPool != null) {  
    7.         //声音池释放资源  
    8.         soundPool.release();  
    9.     }  
    10. }  

    完整的Activity 代码如下：
    [java] view plain copy print?
    1. public class MainActivity extends AppCompatActivity {  
    2.     private ImageView up;  
    3.     private ImageView down;  
    4.     //上一次晃动手机的时间  
    5.     private long lastTime;  
    6.     private SoundPool soundPool;  
    7.     private int sound1;  
    8.     private Vibrator vibrator;  
    9.     private SensorEventListener listener = new SensorEventListener() {  
    10.         //当手机的加速度发生变化时调用  
    11.         @Override  
    12.         public void onSensorChanged(SensorEvent event) {  
    13.             //获取手机在不同方向上加速度的变化  
    14.             float valuesX = Math.abs(event.values[0]);  
    15.             float valuesY = Math.abs(event.values[1]);  
    16.             float valuesZ = Math.abs(event.values[2]);  
    17.   
    18.             if (valuesX > 17 || valuesY > 17 || valuesZ > 17) {  
    19.                 startAnimation();  
    20.                 playSound();  
    21.             }  
    22.         }  
    23.   
    24.         @Override  
    25.         public void onAccuracyChanged(Sensor sensor, int accuracy) {  
    26.   
    27.         }  
    28.     };  
    29.     private SensorManager sensorManager;  
    30.   
    31.     private void playSound() {  
    32.         //1.声音的id  
    33.         //2.3.表示左右声道的音量  
    34.         //4.优先级  
    35.         //5.是否循环  
    36.         //6.声音播放速率  
    37.         soundPool.play(sound1, 1, 1, 0, 0, 1);  
    38.         //手机震动  
    39.         //1.表示震动的节奏off/on/off/on/off/on......  
    40.         //2.表示是否重复震动，-1表示不重复  
    41.         vibrator.vibrate(new long[]{100, 200, 100, 200, 100, 200}, -1);  
    42.     }  
    43.   
    44.     private void startAnimation() {  
    45.         //如果两次晃动手机的时间小于1秒，则只执行一次动画  
    46.         long currentTimeMillis = System.currentTimeMillis();  
    47.         if (currentTimeMillis - lastTime < 1000) {  
    48.             return;  
    49.         }  
    50.         lastTime = currentTimeMillis;  
    51.         AnimationSet upSet = new AnimationSet(true);  
    52.         TranslateAnimation upUp = new TranslateAnimation(TranslateAnimation.RELATIVE_TO_SELF, 0, TranslateAnimation.RELATIVE_TO_SELF,  
    53.                 0, TranslateAnimation.RELATIVE_TO_SELF, 0, TranslateAnimation.RELATIVE_TO_SELF, -1);  
    54.         upUp.setDuration(1000);  
    55.         TranslateAnimation upDown = new TranslateAnimation(TranslateAnimation.RELATIVE_TO_SELF, 0, TranslateAnimation.RELATIVE_TO_SELF,  
    56.                 0, TranslateAnimation.RELATIVE_TO_SELF, 0, TranslateAnimation.RELATIVE_TO_SELF, 1);  
    57.         upDown.setDuration(1000);  
    58.         upDown.setStartOffset(1000);  
    59.         upSet.addAnimation(upUp);  
    60.         upSet.addAnimation(upDown);  
    61.         up.startAnimation(upSet);  
    62.         AnimationSet downSet = new AnimationSet(true);  
    63.         TranslateAnimation downUp = new TranslateAnimation(TranslateAnimation.RELATIVE_TO_SELF, 0, TranslateAnimation.RELATIVE_TO_SELF,  
    64.                 0, TranslateAnimation.RELATIVE_TO_SELF, 0, TranslateAnimation.RELATIVE_TO_SELF, 1);  
    65.         downUp.setDuration(1000);  
    66.         TranslateAnimation downDown = new TranslateAnimation(TranslateAnimation.RELATIVE_TO_SELF, 0, TranslateAnimation.RELATIVE_TO_SELF,  
    67.                 0, TranslateAnimation.RELATIVE_TO_SELF, 0, TranslateAnimation.RELATIVE_TO_SELF, -1);  
    68.         downDown.setDuration(1000);  
    69.         downDown.setStartOffset(1000);  
    70.         downSet.addAnimation(downUp);  
    71.         downSet.addAnimation(downDown);  
    72.         down.startAnimation(downSet);  
    73.     }  
    74.   
    75.     @Override  
    76.     protected void onCreate(Bundle savedInstanceState) {  
    77.         super.onCreate(savedInstanceState);  
    78.         setContentView(R.layout.activity_main);  
    79.         up = ((ImageView) findViewById(R.id.up));  
    80.         down = ((ImageView) findViewById(R.id.down));  
    81.         initSensor();  
    82.         initSoundPool();  
    83.         //获取手机震动服务  
    84.         vibrator = (Vibrator) getSystemService(VIBRATOR_SERVICE);  
    85.     }  
    86.   
    87.     /** 
    88.      * 初始化声音池 
    89.      */  
    90.     private void initSoundPool() {  
    91.         if (Build.VERSION.SDK_INT > 20) {  
    92.             SoundPool.Builder builder = new SoundPool.Builder();  
    93.             //1.最大并发流数  
    94.             builder.setMaxStreams(3);  
    95.             AudioAttributes.Builder aaBuilder = new AudioAttributes.Builder();  
    96.             aaBuilder.setLegacyStreamType(AudioManager.STREAM_MUSIC);  
    97.             builder.setAudioAttributes(aaBuilder.build());  
    98.             soundPool = builder.build();  
    99.         } else {  
    100.             soundPool = new SoundPool(3, AudioManager.STREAM_MUSIC, 0);  
    101.         }  
    102.         //加载一个音频文件  
    103.         sound1 = soundPool.load(this, R.raw.awe, 1);  
    104.     }  
    105.   
    106.     /** 
    107.      * 初始化传感器 
    108.      */  
    109.     private void initSensor() {  
    110.         //获取到一个传感器管理器  
    111.         sensorManager = (SensorManager) getSystemService(SENSOR_SERVICE);  
    112.         //获得一个加速度传感器  
    113.         Sensor sensor = sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);  
    114.         //注册传感器监听，  
    115.         //1.监听器  
    116.         //2.加速度传感器  
    117.         //3.传感器灵敏度  
    118.         //传感器灵敏度分为四级，从上往下灵敏度依次降低  
    119.         //SENSOR_DELAY_FASTEST  
    120.         //SENSOR_DELAY_GAME  
    121.         //SENSOR_DELAY_UI  
    122.         //SENSOR_DELAY_NORMAL  
    123.         sensorManager.registerListener(listener, sensor, SensorManager.SENSOR_DELAY_GAME);  
    124.     }  
    125.   
    126.     @Override  
    127.     protected void onDestroy() {  
    128.         super.onDestroy();  
    129.         //解除对加速度传感器的监听  
    130.         sensorManager.unregisterListener(listener);  
    131.         if (soundPool != null) {  
    132.             //声音池释放资源  
    133.             soundPool.release();  
    134.         }  
    135.     }  
    136. }  

    以上。
  • 相关阅读:
    游戏编程模式之事件队列模式
    游戏编程模式之组件模式
    游戏编程模式之类型对象模式
    游戏编程模式之父类沙盒模式
    游戏编程模式之字节码模式
    游戏人工智能简介
    游戏编程模式之更新模式
    游戏编程模式之游戏循环
    .vimrc配置文件 + gvim 运行 gnome-terminal 完成后等待
    js 批量移除steam游戏 移除用户凭证中免费获取的物品
  • 原文地址：https://www.cnblogs.com/Free-Thinker/p/6544174.html
Copyright © 2020-2023  润新知