Android开发网

首页|Android开发环境|Android开发教程|Android开发视频|Android游戏开发|Android开发实例|Android开发书籍|鸡啄米博客

Android游戏开发教程之十五：小球重力感应

       重力感应主要是依靠手机的加速度传感器(accelerometer)来实现        在Android的开发中一共有八种传感器但是不一定每一款真机都支持这些传感器。因为很多功能用户根本不care的所以可能开发商会把某些功能屏蔽掉。还是得根据真机的实际情况来做开发，今天我们主要来讨论加速度传感器的具体实现方式。

　　传感器名称如下：

　　加速度传感器(accelerometer)

　　陀螺仪传感器(gyroscope)

　　环境光照传感器(light)

　　磁力传感器(magnetic field)

　　方向传感器(orientation)

　　压力传感器(pressure)

　　距离传感器(proximity)

　　温度传感器(temperature)

　　1. SensorMannager传感器管理对象手机中的所有传感器都须要通过SensorMannager来访问，调用getSystemService(SENSOR_SERVICE)方法就可以拿到当前手机的传感器管理对象。

Java代码
  1. SensorManager mSensorMgr = (SensorManager) getSystemService(SENSOR_SERVICE);  

　　2. 实现SensorEventListener接口

　　说道SensorEventListener接口就不得不说SensorListener接口。在Android1.5一下是通过实现SensorListener接口来捕获 手机传感器状态，但是在1.5以上如果实现这个接口系统会提示你这行代码已经过期。今天我们不讨论SensorListener因为它已经是过时的东西了。主要讨论一下SensorEventListener接口。我们须要实现SensorEventListener这个接口 onSensorChanged(SensorEvent event)方法来捕获手机传感器的状态，拿到手机 X轴Y轴Z轴三个方向的重力分量，有了这三个方向的数据重力感应的原理我们就已经学会了，简单吧 哇咔咔~~

Java代码
  1. public void onSensorChanged(SensorEvent e) {  
  2.    float x = e.values[SensorManager.DATA_X];  
  3.    float y = e.values[SensorManager.DATA_Y];  
  4.    float z = e.values[SensorManager.DATA_Z];  
  5. }  

　　如图所示：上例代码中 float x y z 3个方向的取值范围是在 -10 到 10 之间，我向同学们说明一下 X轴 Y轴 Z轴 重力分量的含义。 这里须要注意的是坐标原点 向天空为正数 向地面为负数 刚好与编程时坐标是相反的。

　　手机屏幕向左侧方当X轴就朝向天空，垂直放置 这时候 Y 轴 与 Z轴没有重力分量，因为X轴朝向天空所以它的重力分量则最大 。这时候X轴 Y轴 Z轴的重力分量的值分别为（10，0，0）

　　手机屏幕向右侧方当X轴就朝向地面，垂直放置 这时候 Y 轴 与 Z轴没有重力分量，因为X轴朝向地面所以它的重力分量则最小 。这时候X轴 Y轴 Z轴的重力分量的值分别为（-10，0，0）

　　手机屏幕垂直竖立放置方当Y轴就朝向天空，垂直放置 这时候 X 轴 与 Z轴没有重力分量，因为Y轴朝向天空所以它的重力分量则最大 。这时候X轴 Y轴 Z轴的重力分量的值分别为（0，10，0）

　　手机屏幕垂直竖立放置方当Y轴就朝向地面，垂直放置 这时候 X 轴 与 Z轴没有重力分量，因为Y轴朝向地面所以它的重力分量则最小 。这时候X轴 Y轴 Z轴的重力分量的值分别为（0，-10，0）

　　手机屏幕向上当Z轴就朝向天空，水平放置 这时候 X 轴与Y轴没有重力分量，因为Z轴朝向天空所以它的重力分量则最大 。这时候X轴 Y轴 Z轴的重力分量的值分别为（0，0，10）

　　手机屏幕向上当Z轴就朝向地面，水平放置 这时候 X 轴与Y轴没有重力分量，因为Z轴朝向地面所以它的重力分量则最小 。这时候X轴 Y轴 Z轴的重力分量的值分别为（0，0，-10）

　　因为这张图片是在模拟器上截得，所以没有重力感应它的三个方向的的重力分量都为0。

　　3. 注册SensorEventListener

　　使用SensorMannager调用getDefaultSensor(Sensor.TYPE_ACCELEROMETER)方法拿到加速重力感应的Sensor对象。因为本章我们讨论重力加速度传感器所以参数为Sensor.TYPE_ACCELEROMETER，如果须要拿到其它的传感器须要传入对应的名称。使用SensorMannager调用registerListener()方法来注册，第三个参数是检测的灵敏精确度根据不同的需求来选择精准度，游戏开发建议使用  SensorManager.SENSOR_DELAY_GAME。

Java代码
  1. mSensorMgr = (SensorManager) getSystemService(SENSOR_SERVICE);  
  2. mSensor = mSensorMgr.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);  
  3. // 注册listener，第三个参数是检测的精确度  
  4. //SENSOR_DELAY_FASTEST 最灵敏 因为太快了没必要使用  
  5. //SENSOR_DELAY_GAME    游戏开发中使用  
  6. //SENSOR_DELAY_NORMAL  正常速度  
  7. //SENSOR_DELAY_UI          最慢的速度  
  8. mSensorMgr.registerListener(this, mSensor, SensorManager.SENSOR_DELAY_GAME);   

　　重力感应简单速度计算的方式。 每次摇晃手机计算出 X轴 Y轴 Z轴的重力分量可以将它们记录下来 然后每次摇晃的重力分量和之前的重力分量可以做一个对比 利用差值和时间就可以计算出他们的移动速度。（下面这段代码是我之前的博文中摘录过来的，因为那篇写的不是很好所以在这一篇中我详细总结一下）

Java代码
  1. private SensorManager sensorMgr;  
  2. Sensor sensor = sensorMgr.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);       
  3.   
  4.  //保存上一次 x y z 的坐标  
  5.  float bx = 0;  
  6.  float by = 0;  
  7.  float bz = 0;  
  8.  long btime = 0;//这一次的时间  
  9.  sensorMgr = (SensorManager) getSystemService(SENSOR_SERVICE);  
  10.     SensorEventListener lsn = new SensorEventListener() {  
  11.         public void onSensorChanged(SensorEvent e) {  
  12.            float x = e.values[SensorManager.DATA_X];  
  13.            float y = e.values[SensorManager.DATA_Y];  
  14.            float z = e.values[SensorManager.DATA_Z];  
  15.            //在这里我们可以计算出 X Y Z的数值 下面我们就可以根据这个数值来计算摇晃的速度了  
  16.            //我想大家应该都知道计算速度的公事 速度 = 路程/时间  
  17.            //X轴的速度  
  18.            float speadX = (x - bx) / (System.currentTimeMillis() - btime);  
  19.            //y轴的速度  
  20.            float speadY = (y - by) / (System.currentTimeMillis() - btime);  
  21.            //z轴的速度  
  22.            float speadZ = (z - bz) / (System.currentTimeMillis() - btime);  
  23.            //这样简单的速度就可以计算出来 如果你想计算加速度 也可以 在运动学里，加速度a与速度，  
  24.            //位移都有关系：Vt=V0+at，S=V0*t+1/2at^2， S=（Vt^2-V0^2）/(2a),根据这些信息也可以求解a。  
  25.            //这里就不详细介绍了 公事 应该初中物理课老师就教了呵呵~~    
  26.   
  27.            bx = x;  
  28.            by = y;  
  29.            bz = z;    
  30.   
  31.            btime = System.currentTimeMillis();    
  32.   
  33.         }       
  34.   
  35.         public void onAccuracyChanged(Sensor s, int accuracy) {  
  36.         }  
  37.     };  
  38.     // 注册listener，第三个参数是检测的精确度  
  39.     sensorMgr.registerListener(lsn, sensor, SensorManager.SENSOR_DELAY_GAME);  

　　下面给出这个DEMO小球重力感应的完整代码

Java代码
  1. import android.app.Activity;  
  2. import android.content.Context;  
  3. import android.content.pm.ActivityInfo;  
  4. import android.graphics.Bitmap;  
  5. import android.graphics.BitmapFactory;  
  6. import android.graphics.Canvas;  
  7. import android.graphics.Color;  
  8. import android.graphics.Paint;  
  9. import android.hardware.Sensor;  
  10. import android.hardware.SensorEvent;  
  11. import android.hardware.SensorEventListener;  
  12. import android.hardware.SensorManager;  
  13. import android.os.Bundle;  
  14. import android.view.SurfaceHolder;  
  15. import android.view.SurfaceView;  
  16. import android.view.Window;  
  17. import android.view.WindowManager;  
  18. import android.view.SurfaceHolder.Callback;  
  19.    
  20. public class SurfaceViewAcitvity extends Activity {  
  21.    
  22.     MyView mAnimView = null;  
  23.    
  24.     @Override  
  25.     public void onCreate(Bundle savedInstanceState) {  
  26.     super.onCreate(savedInstanceState);  
  27.     // 全屏显示窗口  
  28.     requestWindowFeature(Window.FEATURE_NO_TITLE);  
  29.     getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,  
  30.         WindowManager.LayoutParams.FLAG_FULLSCREEN);  
  31.     //强制横屏  
  32.     setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);  
  33.    
  34.     // 显示自定义的游戏View  
  35.     mAnimView = new MyView(this);  
  36.     setContentView(mAnimView);  
  37.     }  
  38.    
  39.     public class MyView extends SurfaceView implements Callback,Runnable ,SensorEventListener{  
  40.    
  41.      /**每50帧刷新一次屏幕**/  
  42.     public static final int TIME_IN_FRAME = 50;   
  43.    
  44.     /** 游戏画笔 **/  
  45.     Paint mPaint = null;  
  46.     Paint mTextPaint = null;  
  47.     SurfaceHolder mSurfaceHolder = null;  
  48.    
  49.     /** 控制游戏更新循环 **/  
  50.     boolean mRunning = false;  
  51.    
  52.     /** 游戏画布 **/  
  53.     Canvas mCanvas = null;  
  54.    
  55.     /**控制游戏循环**/  
  56.     boolean mIsRunning = false;  
  57.    
  58.     /**SensorManager管理器**/  
  59.     private SensorManager mSensorMgr = null;  
  60.     Sensor mSensor = null;      
  61.    
  62.     /**手机屏幕宽高**/  
  63.     int mScreenWidth = 0;  
  64.     int mScreenHeight = 0;  
  65.    
  66.     /**小球资源文件越界区域**/  
  67.     private int mScreenBallWidth = 0;  
  68.     private int mScreenBallHeight = 0;  
  69.    
  70.     /**游戏背景文件**/  
  71.     private Bitmap mbitmapBg;  
  72.    
  73.     /**小球资源文件**/  
  74.     private Bitmap mbitmapBall;  
  75.    
  76.     /**小球的坐标位置**/  
  77.     private float mPosX = 200;  
  78.     private float mPosY = 0;  
  79.    
  80.     /**重力感应X轴 Y轴 Z轴的重力值**/  
  81.     private float mGX = 0;  
  82.     private float mGY = 0;  
  83.     private float mGZ = 0;  
  84.    
  85.     public MyView(Context context) {  
  86.         super(context);  
  87.         /** 设置当前View拥有控制焦点 **/  
  88.         this.setFocusable(true);  
  89.         /** 设置当前View拥有触摸事件 **/  
  90.         this.setFocusableInTouchMode(true);  
  91.         /** 拿到SurfaceHolder对象 **/  
  92.         mSurfaceHolder = this.getHolder();  
  93.         /** 将mSurfaceHolder添加到Callback回调函数中 **/  
  94.         mSurfaceHolder.addCallback(this);  
  95.         /** 创建画布 **/  
  96.         mCanvas = new Canvas();  
  97.         /** 创建曲线画笔 **/  
  98.         mPaint = new Paint();  
  99.         mPaint.setColor(Color.WHITE);  
  100.         /**加载小球资源**/  
  101.         mbitmapBall = BitmapFactory.decodeResource(this.getResources(), R.drawable.ball);  
  102.         /**加载游戏背景**/  
  103.         mbitmapBg = BitmapFactory.decodeResource(this.getResources(), R.drawable.bg);  
  104.    
  105.         /**得到SensorManager对象**/  
  106.         mSensorMgr = (SensorManager) getSystemService(SENSOR_SERVICE);  
  107.         mSensor = mSensorMgr.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);  
  108.         // 注册listener，第三个参数是检测的精确度  
  109.             //SENSOR_DELAY_FASTEST 最灵敏 因为太快了没必要使用  
  110.             //SENSOR_DELAY_GAME    游戏开发中使用  
  111.             //SENSOR_DELAY_NORMAL  正常速度  
  112.             //SENSOR_DELAY_UI          最慢的速度  
  113.         mSensorMgr.registerListener(this, mSensor, SensorManager.SENSOR_DELAY_GAME);  
  114.     }  
  115.    
  116.     private void Draw() {  
  117.    
  118.         /**绘制游戏背景**/  
  119.         mCanvas.drawBitmap(mbitmapBg,0,0, mPaint);  
  120.         /**绘制小球**/  
  121.         mCanvas.drawBitmap(mbitmapBall, mPosX,mPosY, mPaint);  
  122.         /**X轴 Y轴 Z轴的重力值**/  
  123.         mCanvas.drawText("X轴重力值 ：" + mGX, 0, 20, mPaint);  
  124.         mCanvas.drawText("Y轴重力值 ：" + mGY, 0, 40, mPaint);  
  125.         mCanvas.drawText("Z轴重力值 ：" + mGZ, 0, 60, mPaint);  
  126.     }  
  127.    
  128.     @Override  
  129.     public void surfaceChanged(SurfaceHolder holder, int format, int width,  
  130.         int height) {  
  131.    
  132.     }  
  133.    
  134.     @Override  
  135.     public void surfaceCreated(SurfaceHolder holder) {  
  136.         /**开始游戏主循环线程**/  
  137.         mIsRunning = true;  
  138.         new Thread(this).start();  
  139.         /**得到当前屏幕宽高**/  
  140.         mScreenWidth = this.getWidth();  
  141.         mScreenHeight = this.getHeight();  
  142.    
  143.         /**得到小球越界区域**/  
  144.         mScreenBallWidth = mScreenWidth - mbitmapBall.getWidth();  
  145.         mScreenBallHeight = mScreenHeight - mbitmapBall.getHeight();  
  146.     }  
  147.    
  148.     @Override  
  149.     public void surfaceDestroyed(SurfaceHolder holder) {  
  150.         mIsRunning = false;  
  151.     }  
  152.    
  153.     @Override  
  154.     public void run() {  
  155.         while (mIsRunning) {  
  156.    
  157.         /** 取得更新游戏之前的时间 **/  
  158.         long startTime = System.currentTimeMillis();  
  159.    
  160.         /** 在这里加上线程安全锁 **/  
  161.         synchronized (mSurfaceHolder) {  
  162.             /** 拿到当前画布 然后锁定 **/  
  163.             mCanvas = mSurfaceHolder.lockCanvas();  
  164.             Draw();  
  165.             /** 绘制结束后解锁显示在屏幕上 **/  
  166.             mSurfaceHolder.unlockCanvasAndPost(mCanvas);  
  167.         }  
  168.    
  169.         /** 取得更新游戏结束的时间 **/  
  170.         long endTime = System.currentTimeMillis();  
  171.    
  172.         /** 计算出游戏一次更新的毫秒数 **/  
  173.         int diffTime = (int) (endTime - startTime);  
  174.    
  175.         /** 确保每次更新时间为50帧 **/  
  176.         while (diffTime <= TIME_IN_FRAME) {  
  177.             diffTime = (int) (System.currentTimeMillis() - startTime);  
  178.             /** 线程等待 **/  
  179.             Thread.yield();  
  180.         }  
  181.    
  182.         }  
  183.    
  184.     }  
  185.    
  186.     @Override  
  187.     public void onAccuracyChanged(Sensor arg0, int arg1) {  
  188.         // TODO Auto-generated method stub  
  189.    
  190.     }  
  191.    
  192.     @Override  
  193.     public void onSensorChanged(SensorEvent event) {  
  194.         mGX = event.values[SensorManager.DATA_X];  
  195.         mGY= event.values[SensorManager.DATA_Y];  
  196.         mGZ = event.values[SensorManager.DATA_Z];  
  197.    
  198.         //这里乘以2是为了让小球移动的更快  
  199.         mPosX -= mGX * 2;  
  200.         mPosY += mGY * 2;  
  201.    
  202.         //检测小球是否超出边界  
  203.         if (mPosX < 0) {  
  204.         mPosX = 0;  
  205.         } else if (mPosX > mScreenBallWidth) {  
  206.         mPosX = mScreenBallWidth;  
  207.         }  
  208.         if (mPosY < 0) {  
  209.         mPosY = 0;  
  210.         } else if (mPosY > mScreenBallHeight) {  
  211.         mPosY = mScreenBallHeight;  
  212.         }  
  213.     }  
  214.     }  
  215. }  

　　源码下载地址：http://vdisk.weibo.com/s/aajXn

Tags:Sensor | 2016/4/11 | 发表评论

相关文章: