Sensor编程

1.Sensor Type
重力感应/加速度传感器 (G-Sensor)
光感应 (Light-Sensor)
温度感应
方向感应
磁场、
临近性

2.如何实现Sensor编程
a.获取系统服务（SENSOR_SERVICE)返回一个SensorManager 对象
sensormanager = (SensorManager)getSystemSeriver(SENSOR_SERVICE);
b.通过SensorManager对象获取相应的Sensor类型的对象
sensorObject = sensormanager.getDefaultSensor(sensor Type);
c.声明一个SensorEventListener 对象用于侦听Sensor 事件，并重载onSensorChanged方法
SensorEventListener sensorListener = new SensorEventListener(){
};
d.注册相应的SensorService
sensormanager.registerListener(sensorListener, sensorObject, Sensor TYPE);
e.销毁相应的SensorService
sensormanager.unregisterListener(sensorListener, sensorObject);

f: SensorListener 接口是传感器应用程序的中心。它包括两个必需方法：
　　 onSensorChanged(int sensor,float values[]) 方法在传感器值更改时调用。

该方法只对受此应用程序监视的传感器调用(更多内容见下文)。该方法的参数包括：一个整数，指示更改的传感器;一个浮点值数组，表示传感器数据本身。有些传感器只提供一个数据值，另一些则提供三个浮点值。方向和加速表传感器都提供三个数据值。

　　当传感器的准确性更改时，将调用 onAccuracyChanged(int sensor,int accuracy) 方法。参数包括两个整数：一个表示传感器，另一个表示该传感器新的准确值。

3.关于G-Sensor
Android 加速度传感器的类型是 Sensor.TYPE_ACCELEROMETER
通过 android.hardware.SensorEvent 返回加速度传感器值。
加速度传感器返回值的单位是加速度的单位 m/s^2(米每二次方秒)，有三个方向的值分别是

　　 values[0]: x-axis 方向加速度
　　values[1]: y-axis 方向加速度
　　values[2]: z-axis 方向加速度

　　其中x,y,z方向的定义是以水平放置在的手机的右下脚为参照系坐标原点
　　x 方向就是手机的水平方向，右为正
　　y 方向就是手机的水平垂直方向，前为正
　　y 方向就是手机的空间垂直方向，天空的方向为正，地球的方向为负
需要注意的是，由于地球固有的重力加速度g (值为9.8 m/s^2)，
　　因此现实中实际加速度值应该是 z方向返回值 - 9.8 m/s^2.
　　比如你以 2 m/s^2 的加速度将手机抛起，这时z方向的返回值应该是 11.8 m/s^2.
　　反之若以手机以2 m/s^2 的加速度坠落，则z方向的返回值应该是 7.8 m/s^2.

　　x,y方向则没有上述限制。

代码：

package com.czz.test;

import android.content.Context;
import android.hardware.Sensor;
import android.hardware.SensorEvent;
import android.hardware.SensorEventListener;
import android.hardware.SensorListener;
import android.hardware.SensorManager;
import android.os.Vibrator;
import android.util.Log;

public class SensorUtils {

	static final String TAG = "SensorUtis";

	private static TesttttActivity mContext;

	private static SensorUtils mSingleInstance;

	private SensorEventListener mSensorEventListener;
	private SensorListener mSensorListener;

	Vibrator mVibrator;

	SensorManager mSensorManager;
	
	Sensor mSensor;

	public SensorUtils(TesttttActivity context) {
		this.mContext = context;
		// TODO Auto-generated constructor stub
	}

	public static SensorUtils getInstance(TesttttActivity context) {
		synchronized(SensorUtils.class) {
			if(mSingleInstance == null) {
				mSingleInstance = new SensorUtils(context);
			}
		}
		mContext = context;
		return mSingleInstance;
	}

	private void setSensorListener() {
		mSensorManager = (SensorManager) mContext.getSystemService(Context.SENSOR_SERVICE);
        mVibrator = (Vibrator) mContext.getSystemService(Context.VIBRATOR_SERVICE);
        mSensor = mSensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);
        
        mSensorEventListener = new SensorEventListener() {

			float x, y, z, lastX, lastY;
			long lastT, lastST;
			@Override
			public void onAccuracyChanged(Sensor sensor, int accuracy) {
				// TODO Auto-generated method stub
				
			}

			@Override
			public void onSensorChanged(SensorEvent event) {
				// TODO Auto-generated method stub
				long currT = System.currentTimeMillis();
				if((currT - lastT) > 100) {
					long diffT = (currT - lastT);
					lastT = currT;
					
					x = event.values[SensorManager.DATA_X];
					y = event.values[SensorManager.DATA_Y];
					z = event.values[SensorManager.DATA_Z];
					Log.i(TAG, "x="+x+" y="+y+"z="+z);
					float axis = 0;
					if(lastX != 0) {
						axis = Math.abs((x+y-lastX-lastY))/diffT*10000;
					}
					if(axis > 1200 && (currT - lastST) > 200) {
						lastST = currT;
						mVibrator.vibrate(new long[] {500,100,1000}, -1);
						mContext.refreshView();
					}
					lastX = x;
					lastY = y;
				}
				
			}
        	
        };
        mSensorManager.registerListener(mSensorEventListener, mSensor, SensorManager.SENSOR_DELAY_GAME);
	}
	private void setShakeListener() {
        mSensorManager = (SensorManager) mContext.getSystemService(Context.SENSOR_SERVICE);
        mVibrator = (Vibrator) mContext.getSystemService(Context.VIBRATOR_SERVICE);

        mSensorListener = new SensorListener() {
            long lastUpdate, lastShakeTime = 0;

            static final int SHAKE_THRESHOLD = 1200;

            float x, y, last_x = 0, last_y = 0;

            public void onAccuracyChanged(int sensor, int accuracy) {
                // TODO Auto-generated method stub
            }

            public void onSensorChanged(int sensor, float[] values) {

                if (sensor == SensorManager.SENSOR_ACCELEROMETER) {
                    long curTime = System.currentTimeMillis();

                    if ((curTime - lastUpdate) > 100) {
                        long diffTime = (curTime - lastUpdate);
                        lastUpdate = curTime;
                        x = values[SensorManager.DATA_X];
                        y = values[SensorManager.DATA_Y];
                        float acceChangeRate = 0;
                        if (last_x != 0) {
                            acceChangeRate = Math.abs(x + y - last_x - last_y) / diffTime * 10000;
                           }
                        if (acceChangeRate > SHAKE_THRESHOLD && curTime - lastShakeTime > 200) {
                            lastShakeTime = curTime;
                            mVibrator.vibrate(new long[] {
                                    500, 100, 1000
                            }, -1);
                            mContext.refreshView();
                        }
                        last_x = x;
                        last_y = y;
                    }
                }
            }
        };
        mSensorManager.registerListener(mSensorListener, SensorManager.SENSOR_ACCELEROMETER);
    }
	/* RK_ID: , Aut: */
    public void registerShakeListener() {
        Log.i(TAG, "registerShakeListener >>>>>>>>> ");
        if (mContext == null) {
            return;
        }
//        setShakeListener();
        setSensorListener();
    }

    /* RK_ID: , Aut: */
    public void resetShakeListener() {
        Log.i(TAG, "resetShakeListener >>>>>>>>> ");
        if (mContext == null)
            return;

        if (null != mVibrator) {
            mVibrator.cancel();
            mVibrator = null;
        }
        if (null != mSensorManager) {
            mSensorManager.unregisterListener(mSensorListener, SensorManager.SENSOR_ACCELEROMETER);
        }
    }
}