Comment agiter sur Android 2.2

Question

Est-ce que quelqu'un sait quel est le code de secousse pour Android 2.2? Je veux sur shake faire du buzz sur mon application. Merci.

Answer 1

Essayez ceci:

/* put this into your activity class */ 
    private SensorManager mSensorManager; 
    private float mAccel; // acceleration apart from gravity 
    private float mAccelCurrent; // current acceleration including gravity 
    private float mAccelLast; // last acceleration including gravity 

    private final SensorEventListener mSensorListener = new SensorEventListener() { 

    public void onSensorChanged(SensorEvent se) { 
     float x = se.values[0]; 
     float y = se.values[1]; 
     float z = se.values[2]; 
     mAccelLast = mAccelCurrent; 
     mAccelCurrent = (float) Math.sqrt((double) (x*x + y*y + z*z)); 
     float delta = mAccelCurrent - mAccelLast; 
     mAccel = mAccel * 0.9f + delta; // perform low-cut filter 
    } 

    public void onAccuracyChanged(Sensor sensor, int accuracy) { 
    } 
    }; 

    @Override 
    protected void onResume() { 
    super.onResume(); 
    mSensorManager.registerListener(mSensorListener, mSensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER), SensorManager.SENSOR_DELAY_NORMAL); 
    } 

    @Override 
    protected void onStop() { 
    mSensorManager.unregisterListener(mSensorListener); 
    super.onStop(); 
    } 

Source

Answer 2

On l'appelle "vibreur", en tant que tel, car la classe en question est Vibreur.

http://developer.android.com/reference/android/os/Vibrator.html

Answer 3

Si vous voulez détecter personnes secouant le téléphone, vous devez implémenter l'interface SensorEventListener et rechercher des événements de l'accéléromètre.

Answer 4

Voici mon code pour la détection de mouvement de secousse:

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 = 200; 

    /** Maximum allowed time for shake gesture. */ 
    private static final int MAX_TOTAL_DURATION_OF_SHAKE = 400; 

    /** 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 < MAX_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) { 
    } 

} 

Ajouter dans votre activité:

private SensorManager mSensorManager; 

    private ShakeEventListener mSensorListener; 

...

dans onCreate() ajouter:

mSensorListener = new ShakeEventListener(); 
    mSensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE); 
    mSensorManager.registerListener(mSensorListener, 
     mSensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER), 
     SensorManager.SENSOR_DELAY_UI); 


    mSensorListener.setOnShakeListener(new ShakeEventListener.OnShakeListener() { 

     public void onShake() { 
     Toast.makeText(Activity.this, "Shake!", Toast.LENGTH_SHORT).show(); 
     } 
    }); 

et:

@Override 
    protected void onResume() { 
    super.onResume(); 
    mSensorManager.registerListener(mSensorListener, 
     mSensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER), 
     SensorManager.SENSOR_DELAY_UI); 
    } 

    @Override 
    protected void onStop() { 
    mSensorManager.unregisterListener(mSensorListener); 
    super.onStop(); 
    }