AccelerometerPlay - Accelerometer Play

package com.accelerometer.play; import android.app.Activity; import android.content.Context; import android.graphics.Bitmap; import android.graphics.BitmapFactory; import android.graphics.Canvas; import android.graphics.BitmapFactory.Options; import android.hardware.Sensor; import android.hardware.SensorEvent; import android.hardware.SensorEventListener; import android.hardware.SensorManager; import android.os.Bundle; import android.os.PowerManager; import android.os.PowerManager.WakeLock; import android.util.DisplayMetrics; import android.view.Display; import android.view.Surface; import android.view.View; import android.view.WindowManager; /** * This is an example of using the accelerometer to integrate the device's * acceleration to a position using the Verlet method. This is illustrated with * a very simple particle system comprised of a few iron balls freely moving on * an inclined wooden table. The inclination of the virtual table is controlled * by the device's accelerometer. * * @see SensorManager * @see SensorEvent * @see Sensor */ public class AccelerometerPlayActivity extends Activity { private SimulationView mSimulationView; private SensorManager mSensorManager; private PowerManager mPowerManager; private WindowManager mWindowManager; private Display mDisplay; private WakeLock mWakeLock; /** Called when the activity is first created. */ @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); // Get an instance of the SensorManager mSensorManager = (SensorManager) getSystemService(SENSOR_SERVICE); // Get an instance of the PowerManager mPowerManager = (PowerManager) getSystemService(POWER_SERVICE); // Get an instance of the WindowManager mWindowManager = (WindowManager) getSystemService(WINDOW_SERVICE); mDisplay = mWindowManager.getDefaultDisplay(); // Create a bright wake lock mWakeLock = mPowerManager.newWakeLock(PowerManager.SCREEN_BRIGHT_WAKE_LOCK, getClass() .getName()); // instantiate our simulation view and set it as the activity's content mSimulationView = new SimulationView(this); setContentView(mSimulationView); } @Override protected void onResume() { super.onResume(); /* * when the activity is resumed, we acquire a wake-lock so that the * screen stays on, since the user will likely not be fiddling with the * screen or buttons. */ mWakeLock.acquire(); // Start the simulation mSimulationView.startSimulation(); } @Override protected void onPause() { super.onPause(); /* * When the activity is paused, we make sure to stop the simulation, * release our sensor resources and wake locks */ // Stop the simulation mSimulationView.stopSimulation(); // and release our wake-lock mWakeLock.release(); } class SimulationView extends View implements SensorEventListener { // diameter of the balls in meters private static final float sBallDiameter = 0.004f; private static final float sBallDiameter2 = sBallDiameter * sBallDiameter; // friction of the virtual table and air private static final float sFriction = 0.1f; private Sensor mAccelerometer; private long mLastT; private float mLastDeltaT; private float mXDpi; private float mYDpi; private float mMetersToPixelsX; private float mMetersToPixelsY; private Bitmap mBitmap; private Bitmap mWood; private float mXOrigin; private float mYOrigin; private float mSensorX; private float mSensorY; private long mSensorTimeStamp; private long mCpuTimeStamp; private float mHorizontalBound; private float mVerticalBound; private final ParticleSystem mParticleSystem = new ParticleSystem(); /* * Each of our particle holds its previous and current position, its * acceleration. for added realism each particle has its own friction * coefficient. */ class Particle { private float mPosX; private float mPosY; private float mAccelX; private float mAccelY; private float mLastPosX; private float mLastPosY; private float mOneMinusFriction; Particle() { // make each particle a bit different by randomizing its // coefficient of friction final float r = ((float) Math.random() - 0.5f) * 0.2f; mOneMinusFriction = 1.0f - sFriction + r; } public void computePhysics(float sx, float sy, float dT, float dTC) { // Force of gravity applied to our virtual object final float m = 1000.0f; // mass of our virtual object final float gx = -sx * m; final float gy = -sy * m; /* * �F = mA <=> A = �F / m We could simplify the code by * completely eliminating "m" (the mass) from all the equations, * but it would hide the concepts from this sample code. */ final float invm = 1.0f / m; final float ax = gx * invm; final float ay = gy * invm; /* * Time-corrected Verlet integration The position Verlet * integrator is defined as x(t+�t) = x(t) + x(t) - x(t-�t) + * a(t)�t�2 However, the above equation doesn't handle variable * �t very well, a time-corrected version is needed: x(t+�t) = * x(t) + (x(t) - x(t-�t)) * (�t/�t_prev) + a(t)�t�2 We also add * a simple friction term (f) to the equation: x(t+�t) = x(t) + * (1-f) * (x(t) - x(t-�t)) * (�t/�t_prev) + a(t)�t�2 */ final float dTdT = dT * dT; final float x = mPosX + mOneMinusFriction * dTC * (mPosX - mLastPosX) + mAccelX * dTdT; final float y = mPosY + mOneMinusFriction * dTC * (mPosY - mLastPosY) + mAccelY * dTdT; mLastPosX = mPosX; mLastPosY = mPosY; mPosX = x; mPosY = y; mAccelX = ax; mAccelY = ay; } /* * Resolving constraints and collisions with the Verlet integrator * can be very simple, we simply need to move a colliding or * constrained particle in such way that the constraint is * satisfied. */ public void resolveCollisionWithBounds() { final float xmax = mHorizontalBound; final float ymax = mVerticalBound; final float x = mPosX; final float y = mPosY; if (x > xmax) { mPosX = xmax; } else if (x < -xmax) { mPosX = -xmax; } if (y > ymax) { mPosY = ymax; } else if (y < -ymax) { mPosY = -ymax; } } } /* * A particle system is just a collection of particles */ class ParticleSystem { static final int NUM_PARTICLES = 15; private Particle mBalls[] = new Particle[NUM_PARTICLES]; ParticleSystem() { /* * Initially our particles have no speed or acceleration */ for (int i = 0; i < mBalls.length; i++) { mBalls[i] = new