Android 检测震动8秒
我使用加速计进行震动检测，但我想如果用户将震动他们的设备8秒，则会触发产生的方法。 用我目前的代码a可以检测到震动，但我也想要一个8秒计时器。 我现在的代码是Android 检测震动8秒,android,accelerometer,Android,Accelerometer,我使用加速计进行震动检测，但我想如果用户将震动他们的设备8秒，则会触发产生的方法。 用我目前的代码a可以检测到震动，但我也想要一个8秒计时器。 我现在的代码是 public class AccelerometerManager { private static Context aContext=null; /** Accuracy configuration */ private static float threshold = 15.0f; private
public class AccelerometerManager {
private static Context aContext=null;
/** Accuracy configuration */
private static float threshold = 15.0f;
private static int interval = 200;
private static Sensor sensor;
private static SensorManager sensorManager;
// you could use an OrientationListener array instead
// if you plans to use more than one listener
private static AccelerometerListener listener;
/** indicates whether or not Accelerometer Sensor is supported */
private static Boolean supported;
/** indicates whether or not Accelerometer Sensor is running */
private static boolean running = false;
/**
* Returns true if the manager is listening to orientation changes
*/
public static boolean isListening() {
return running;
}
/**
* Unregisters listeners
*/
public static void stopListening() {
running = false;
try {
if (sensorManager != null && sensorEventListener != null) {
sensorManager.unregisterListener(sensorEventListener);
}
} catch (Exception e) {}
}
/**
* Returns true if at least one Accelerometer sensor is available
*/
public static boolean isSupported(Context context) {
aContext = context;
if (supported == null) {
if (aContext != null) {
sensorManager = (SensorManager) aContext.
getSystemService(Context.SENSOR_SERVICE);
// Get all sensors in device
List<Sensor> sensors = sensorManager.getSensorList(
Sensor.TYPE_ACCELEROMETER);
supported = new Boolean(sensors.size() > 0);
} else {
supported = Boolean.FALSE;
}
}
return supported;
}
/**
* Configure the listener for shaking
* @param threshold
* minimum acceleration variation for considering shaking
* @param interval
* minimum interval between to shake events
*/
public static void configure(int threshold, int interval) {
AccelerometerManager.threshold = threshold;
AccelerometerManager.interval = interval;
}
/**
* Registers a listener and start listening
* @param accelerometerListener
* callback for accelerometer events
*/
public static void startListening( AccelerometerListener accelerometerListener )
{
sensorManager = (SensorManager) aContext.
getSystemService(Context.SENSOR_SERVICE);
// Take all sensors in device
List<Sensor> sensors = sensorManager.getSensorList(
Sensor.TYPE_ACCELEROMETER);
if (sensors.size() > 0) {
sensor = sensors.get(0);
// Register Accelerometer Listener
running = sensorManager.registerListener(
sensorEventListener, sensor,
SensorManager.SENSOR_DELAY_GAME);
listener = accelerometerListener;
}
}
/**
* Configures threshold and interval
* And registers a listener and start listening
* @param accelerometerListener
* callback for accelerometer events
* @param threshold
* minimum acceleration variation for considering shaking
* @param interval
* minimum interval between to shake events
*/
public static void startListening(
AccelerometerListener accelerometerListener,
int threshold, int interval) {
configure(threshold, interval);
startListening(accelerometerListener);
}
/**
* The listener that listen to events from the accelerometer listener
*/
private static SensorEventListener sensorEventListener =
new SensorEventListener() {
private long now = 0;
private long timeDiff = 0;
private long lastUpdate = 0;
private long lastShake = 0;
private float x = 0;
private float y = 0;
private float z = 0;
private float lastX = 0;
private float lastY = 0;
private float lastZ = 0;
private float force = 0;
public void onAccuracyChanged(Sensor sensor, int accuracy) {}
public void onSensorChanged(SensorEvent event) {
// use the event timestamp as reference
// so the manager precision won't depends
// on the AccelerometerListener implementation
// processing time
now = event.timestamp;
x = event.values[0];
y = event.values[1];
z = event.values[2];
// if not interesting in shake events
// just remove the whole if then else block
if (lastUpdate == 0) {
lastUpdate = now;
lastShake = now;
lastX = x;
lastY = y;
lastZ = z;
Toast.makeText(aContext,"No Motion detected",
Toast.LENGTH_SHORT).show();
} else {
timeDiff = now - lastUpdate;
if (timeDiff > 0) {
/*force = Math.abs(x + y + z - lastX - lastY - lastZ)
/ timeDiff;*/
force = Math.abs(x + y + z - lastX - lastY - lastZ);
if (Float.compare(force, threshold) >0 ) {
if (now - lastShake >= 8000000000l) {
// trigger shake event
listener.onShake(force);
}
else
{
Toast.makeText(aContext,"No Motion detected",
Toast.LENGTH_SHORT).show();
}
lastShake = now;
}
lastX = x;
lastY = y;
lastZ = z;
lastUpdate = now;
}
else
{
Toast.makeText(aContext,"No Motion detected", Toast.LENGTH_SHORT).show();
}
}
// trigger change event
listener.onAccelerationChanged(x, y, z);
}
};
}
公共类AccelerometerManager{
私有静态上下文aContext=null；
/**精度配置*/
专用静态浮动阈值=15.0f；
专用静态int间隔=200；
专用静态传感器；
专用静态传感器管理器；
//您可以改用OrientionListener数组
//如果您计划使用多个侦听器
专用静态加速度计监听器；
/**指示是否支持加速计传感器*/
支持私有静态布尔；
/**指示加速计传感器是否正在运行*/
私有静态布尔运行=false；
/**
*如果管理器正在侦听方向更改，则返回true
*/
公共静态布尔isListening（）{
返回运行；
}
/**
*注销侦听器
*/
公共静态void stopListening（）{
运行=错误；
试一试{
if（sensorManager！=null&&sensorEventListener！=null）{
sensorManager.unregisterListener（sensorEventListener）；
}
}捕获（例外e）{}
}
/**
*如果至少有一个加速计传感器可用，则返回true
*/
公共静态布尔值isSupported（上下文）{
文本=上下文；
if（受支持==null）{
如果（aContext！=null）{
sensorManager=（sensorManager）A文本。
getSystemService（Context.SENSOR\u服务）；
//将所有传感器放入设备中
列出传感器=sensorManager.getSensorList(
传感器（U型加速度计）；
支持=新布尔值（sensors.size（）>0）；
}否则{
supported=Boolean.FALSE；
}
}
支持返回；
}
/**
*将侦听器配置为抖动
*@param阈值
*考虑震动的最小加速度变化
*@param间隔
*震动事件之间的最小间隔
*/
公共静态无效配置（int阈值、int间隔）{
AccelerometerManager.threshold=阈值；
AccelerometerManager.interval=间隔；
}
/**
*注册侦听器并开始侦听
*@param加速度计指示器
*加速度计事件的回调
*/
公共静态侦听（AccelerometerListener AccelerometerListener）
{
sensorManager=（sensorManager）A文本。
getSystemService（Context.SENSOR\u服务）；
//将所有传感器放入设备中
列出传感器=sensorManager.getSensorList(
传感器（U型加速度计）；
如果（sensors.size（）>0）{
传感器=传感器。获取（0）；
//寄存器加速计侦听器
正在运行=sensorManager.registerListener(
sensorEventListener，传感器，
传感器管理器。传感器（延迟游戏）；
监听器=加速计监听器；
}
}
/**
*配置阈值和间隔
*注册一个侦听器并开始侦听
*@param加速度计指示器
*加速度计事件的回调
*@param阈值
*考虑震动的最小加速度变化
*@param间隔
*震动事件之间的最小间隔
*/
公共静态侦听(
加速度计传感器加速度计传感器，
整数阈值，整数间隔）{
配置（阈值、间隔）；
震动监听器（加速度计监听器）；
}
/**
*侦听来自加速计侦听器的事件的侦听器
*/
私有静态SensorEventListener SensorEventListener=
新的SensorEventListener（）{
私人long now=0；
私有长时间差=0；
private long lastUpdate=0；
私有长拉斯达克=0；
私有浮动x=0；
私有浮动y=0；
私有浮动z=0；
私有浮动lastX=0；
私人浮动弹性=0；
私有浮动lastZ=0；
私人浮力=0；
精度已更改（传感器，int精度）{}
传感器更改时的公共无效（传感器事件）{
//使用事件时间戳作为参考
//因此，管理器的精度不取决于
//关于加速度计侦听器的实现
//处理时间
现在=event.timestamp；
x=事件值[0]；
y=事件值[1]；
z=事件值[2]；
//如果对震动事件不感兴趣
//只需移除整个if-then-else块
如果（lastUpdate==0）{
lastUpdate=now；
lastShake=现在；
lastX=x；
lastY=y；
lastZ=z；
Toast.makeText（aContext，“未检测到任何运动”，
吐司。长度（短）。show（）；
}否则{
timeDiff=now-lastUpdate；
如果（时间差>0）{
/*力=Math.abs（x+y+z-lastX-lastY-lastZ）
/时间差*/
力=Math.abs（x+y+z-lastX-lastY-lastZ）；
如果(
import android.hardware.Sensor;
import android.hardware.SensorEvent;
import android.hardware.SensorEventListener;
import android.hardware.SensorManager;
/**
* Listener that detects shake gesture.
*/
public class ShakeEventListener implements SensorEventListener {
/** Minimum movement force to consider. */
private static final int MIN_FORCE = 10;
/**
* Minimum times in a shake gesture that the direction of movement needs to
* change.
*/
private static final int MIN_DIRECTION_CHANGE = 3;
/** Maximum pause between movements. */
private static final int MAX_PAUSE_BETHWEEN_DIRECTION_CHANGE = 1000;
/** Minimum allowed time for shake gesture. */
private static final int MIN_TOTAL_DURATION_OF_SHAKE = 8000; // 8 seconds
/** Time when the gesture started. */
private long mFirstDirectionChangeTime = 0;
/** Time when the last movement started. */
private long mLastDirectionChangeTime;
/** How many movements are considered so far. */
private int mDirectionChangeCount = 0;
/** The last x position. */
private float lastX = 0;
/** The last y position. */
private float lastY = 0;
/** The last z position. */
private float lastZ = 0;
/** OnShakeListener that is called when shake is detected. */
private OnShakeListener mShakeListener;
/**
* Interface for shake gesture.
*/
public interface OnShakeListener {
/**
* Called when shake gesture is detected.
*/
void onShake();
}
public void setOnShakeListener(OnShakeListener listener) {
mShakeListener = listener;
}
@Override
public void onSensorChanged(SensorEvent se) {
// get sensor data
float x = se.values[SensorManager.DATA_X];
float y = se.values[SensorManager.DATA_Y];
float z = se.values[SensorManager.DATA_Z];
// calculate movement
float totalMovement = Math.abs(x + y + z - lastX - lastY - lastZ);
if (totalMovement > MIN_FORCE) {
// get time
long now = System.currentTimeMillis();
// store first movement time
if (mFirstDirectionChangeTime == 0) {
mFirstDirectionChangeTime = now;
mLastDirectionChangeTime = now;
}
// check if the last movement was not long ago
long lastChangeWasAgo = now - mLastDirectionChangeTime;
if (lastChangeWasAgo < MAX_PAUSE_BETHWEEN_DIRECTION_CHANGE) {
// store movement data
mLastDirectionChangeTime = now;
mDirectionChangeCount++;
// store last sensor data
lastX = x;
lastY = y;
lastZ = z;
// check how many movements are so far
if (mDirectionChangeCount >= MIN_DIRECTION_CHANGE) {
// check total duration
long totalDuration = now - mFirstDirectionChangeTime;
if (totalDuration >= MIN_TOTAL_DURATION_OF_SHAKE) {
mShakeListener.onShake();
resetShakeParameters();
}
}
} else {
resetShakeParameters();
}
}
}
/**
* Resets the shake parameters to their default values.
*/
private void resetShakeParameters() {
mFirstDirectionChangeTime = 0;
mDirectionChangeCount = 0;
mLastDirectionChangeTime = 0;
lastX = 0;
lastY = 0;
lastZ = 0;
}
@Override
public void onAccuracyChanged(Sensor sensor, int accuracy) {
}
}
private SensorManager mSensorManager;
private ShakeEventListener mSensorListener;
mSensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
mSensorListener = new ShakeEventListener();
mSensorListener.setOnShakeListener(new ShakeEventListener.OnShakeListener() {
public void onShake() {
Toast.makeText(this, "Shake detected!", Toast.LENGTH_SHORT).show();
}
});
@Override
protected void onResume() {
super.onResume();
mSensorManager.registerListener(mSensorListener,
mSensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER),
SensorManager.SENSOR_DELAY_UI);
}
@Override
protected void onPause() {
mSensorManager.unregisterListener(mSensorListener);
super.onPause();
}