Reformat to Android style guidelines

Change-Id: Ib9d7e39464a246dbaae38e00fbb325f153f89f65

1 files changed, 408 insertions, 431 deletions

diff --git a/samples/AccelerometerPlay/src/com/example/android/accelerometerplay/AccelerometerPlayActivity.java b/samples/AccelerometerPlay/src/com/example/android/accelerometerplay/AccelerometerPlayActivity.java
index d9ba954fc..c9e840fd1 100644
--- a/samples/AccelerometerPlay/src/com/example/android/accelerometerplay/AccelerometerPlayActivity.java
+++ b/samples/AccelerometerPlay/src/com/example/android/accelerometerplay/AccelerometerPlayActivity.java
@@ -49,435 +49,412 @@ import android.view.WindowManager;
 
 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 Particle();
-				}
-			}
-
-			/*
-			 * Update the position of each particle in the system using the
-			 * Verlet integrator.
-			 */
-			private void updatePositions(float sx, float sy, long timestamp) {
-				final long t = timestamp;
-				if (mLastT != 0) {
-					final float dT = (float) (t - mLastT)
-							* (1.0f / 1000000000.0f);
-					if (mLastDeltaT != 0) {
-						final float dTC = dT / mLastDeltaT;
-						final int count = mBalls.length;
-						for (int i = 0; i < count; i++) {
-							Particle ball = mBalls[i];
-							ball.computePhysics(sx, sy, dT, dTC);
-						}
-					}
-					mLastDeltaT = dT;
-				}
-				mLastT = t;
-			}
-
-			/*
-			 * Performs one iteration of the simulation. First updating the
-			 * position of all the particles and resolving the constraints and
-			 * collisions.
-			 */
-			public void update(float sx, float sy, long now) {
-				// update the system's positions
-				updatePositions(sx, sy, now);
-
-				// We do no more than a limited number of iterations
-				final int NUM_MAX_ITERATIONS = 10;
-
-				/*
-				 * Resolve collisions, each particle is tested against every
-				 * other particle for collision. If a collision is detected the
-				 * particle is moved away using a virtual spring of infinite
-				 * stiffness.
-				 */
-				boolean more = true;
-				final int count = mBalls.length;
-				for (int k = 0; k < NUM_MAX_ITERATIONS && more; k++) {
-					more = false;
-					for (int i = 0; i < count; i++) {
-						Particle curr = mBalls[i];
-						for (int j = i + 1; j < count; j++) {
-							Particle ball = mBalls[j];
-							float dx = ball.mPosX - curr.mPosX;
-							float dy = ball.mPosY - curr.mPosY;
-							float dd = dx * dx + dy * dy;
-							// Check for collisions
-							if (dd <= sBallDiameter2) {
-								/*
-								 * add a little bit of entropy, after nothing is
-								 * perfect in the universe.
-								 */
-								dx += ((float) Math.random() - 0.5f) * 0.0001f;
-								dy += ((float) Math.random() - 0.5f) * 0.0001f;
-								dd = dx * dx + dy * dy;
-								// simulate the spring
-								final float d = (float) Math.sqrt(dd);
-								final float c = (0.5f * (sBallDiameter - d))
-										/ d;
-								curr.mPosX -= dx * c;
-								curr.mPosY -= dy * c;
-								ball.mPosX += dx * c;
-								ball.mPosY += dy * c;
-								more = true;
-							}
-						}
-						/*
-						 * Finally make sure the particle doesn't intersects
-						 * with the walls.
-						 */
-						curr.resolveCollisionWithBounds();
-					}
-				}
-			}
-
-			public int getParticleCount() {
-				return mBalls.length;
-			}
-
-			public float getPosX(int i) {
-				return mBalls[i].mPosX;
-			}
-
-			public float getPosY(int i) {
-				return mBalls[i].mPosY;
-			}
-		}
-
-		public void startSimulation() {
-			/*
-			 * It is not necessary to get accelerometer events at a very high
-			 * rate, by using a slower rate (SENSOR_DELAY_UI), we get an
-			 * automatic low-pass filter, which "extracts" the gravity component
-			 * of the acceleration. As an added benefit, we use less power and
-			 * CPU resources.
-			 */
-			mSensorManager.registerListener(this, mAccelerometer,
-					SensorManager.SENSOR_DELAY_UI);
-		}
-
-		public void stopSimulation() {
-			mSensorManager.unregisterListener(this);
-		}
-
-		public SimulationView(Context context) {
-			super(context);
-			mAccelerometer = mSensorManager
-					.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);
-
-			DisplayMetrics metrics = new DisplayMetrics();
-			getWindowManager().getDefaultDisplay().getMetrics(metrics);
-			mXDpi = metrics.xdpi;
-			mYDpi = metrics.ydpi;
-			mMetersToPixelsX = mXDpi / 0.0254f;
-			mMetersToPixelsY = mYDpi / 0.0254f;
-
-			// rescale the ball so it's about 0.5 cm on screen
-			Bitmap ball = BitmapFactory.decodeResource(getResources(),
-					R.drawable.ball);
-			final int dstWidth = (int) (sBallDiameter * mMetersToPixelsX + 0.5f);
-			final int dstHeight = (int) (sBallDiameter * mMetersToPixelsY + 0.5f);
-			mBitmap = Bitmap
-					.createScaledBitmap(ball, dstWidth, dstHeight, true);
-
-			Options opts = new Options();
-			opts.inDither = true;
-			opts.inPreferredConfig = Bitmap.Config.RGB_565;
-			mWood = BitmapFactory.decodeResource(getResources(),
-					R.drawable.wood, opts);
-		}
-
-		@Override
-		protected void onSizeChanged(int w, int h, int oldw, int oldh) {
-			// compute the origin of the screen relative to the origin of
-			// the bitmap
-			mXOrigin = (w - mBitmap.getWidth()) * 0.5f;
-			mYOrigin = (h - mBitmap.getHeight()) * 0.5f;
-			mHorizontalBound = ((w / mMetersToPixelsX - sBallDiameter) * 0.5f);
-			mVerticalBound = ((h / mMetersToPixelsY - sBallDiameter) * 0.5f);
-		}
-
-		@Override
-		public void onSensorChanged(SensorEvent event) {
-			if (event.sensor.getType() != Sensor.TYPE_ACCELEROMETER)
-				return;
-			/*
-			 * record the accelerometer data, the event's timestamp as well as
-			 * the current time. The latter is needed so we can calculate the
-			 * "present" time during rendering.
-			 *
-			 * In this application, we need to take into account how the
-			 * screen is rotated with respect to the sensors (which always
-			 * return data in a coordinate space aligned to with the screen
-			 * in its native orientation).
-			 *
-			 */
-
-			switch (mDisplay.getRotation()) {
-				case Surface.ROTATION_0:
-					mSensorX = event.values[0];
-					mSensorY = event.values[1];
-					break;
-				case Surface.ROTATION_90:
-					mSensorX = -event.values[1];
-					mSensorY =  event.values[0];
-					break;
-				case Surface.ROTATION_180:
-					mSensorX = -event.values[0];
-					mSensorY = -event.values[1];
-					break;
-				case Surface.ROTATION_270:
-					mSensorX =  event.values[1];
-					mSensorY = -event.values[0];
-					break;
-			}
-
-			mSensorTimeStamp = event.timestamp;
-			mCpuTimeStamp = System.nanoTime();
-		}
-
-		@Override
-		protected void onDraw(Canvas canvas) {
-
-			/*
-			 * draw the background
-			 */
-
-			canvas.drawBitmap(mWood, 0, 0, null);
-
-			/*
-			 * compute the new position of our object, based on accelerometer
-			 * data and present time.
-			 */
-
-			final ParticleSystem particleSystem = mParticleSystem;
-			final long now = mSensorTimeStamp
-					+ (System.nanoTime() - mCpuTimeStamp);
-			final float sx = mSensorX;
-			final float sy = mSensorY;
-
-			particleSystem.update(sx, sy, now);
-
-			final float xc = mXOrigin;
-			final float yc = mYOrigin;
-			final float xs = mMetersToPixelsX;
-			final float ys = mMetersToPixelsY;
-			final Bitmap bitmap = mBitmap;
-			final int count = particleSystem.getParticleCount();
-			for (int i = 0; i < count; i++) {
-				/*
-				 * We transform the canvas so that the coordinate system matches
-				 * the sensors coordinate system with the origin in the center
-				 * of the screen and the unit is the meter.
-				 */
-
-				final float x = xc + particleSystem.getPosX(i) * xs;
-				final float y = yc - particleSystem.getPosY(i) * ys;
-				canvas.drawBitmap(bitmap, x, y, null);
-			}
-
-			// and make sure to redraw asap
-			invalidate();
-		}
-
-		@Override
-		public void onAccuracyChanged(Sensor sensor, int accuracy) {
-		}
-	}
+    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 Particle();
+                }
+            }
+
+            /*
+             * Update the position of each particle in the system using the
+             * Verlet integrator.
+             */
+            private void updatePositions(float sx, float sy, long timestamp) {
+                final long t = timestamp;
+                if (mLastT != 0) {
+                    final float dT = (float) (t - mLastT) * (1.0f / 1000000000.0f);
+                    if (mLastDeltaT != 0) {
+                        final float dTC = dT / mLastDeltaT;
+                        final int count = mBalls.length;
+                        for (int i = 0; i < count; i++) {
+                            Particle ball = mBalls[i];
+                            ball.computePhysics(sx, sy, dT, dTC);
+                        }
+                    }
+                    mLastDeltaT = dT;
+                }
+                mLastT = t;
+            }
+
+            /*
+             * Performs one iteration of the simulation. First updating the
+             * position of all the particles and resolving the constraints and
+             * collisions.
+             */
+            public void update(float sx, float sy, long now) {
+                // update the system's positions
+                updatePositions(sx, sy, now);
+
+                // We do no more than a limited number of iterations
+                final int NUM_MAX_ITERATIONS = 10;
+
+                /*
+                 * Resolve collisions, each particle is tested against every
+                 * other particle for collision. If a collision is detected the
+                 * particle is moved away using a virtual spring of infinite
+                 * stiffness.
+                 */
+                boolean more = true;
+                final int count = mBalls.length;
+                for (int k = 0; k < NUM_MAX_ITERATIONS && more; k++) {
+                    more = false;
+                    for (int i = 0; i < count; i++) {
+                        Particle curr = mBalls[i];
+                        for (int j = i + 1; j < count; j++) {
+                            Particle ball = mBalls[j];
+                            float dx = ball.mPosX - curr.mPosX;
+                            float dy = ball.mPosY - curr.mPosY;
+                            float dd = dx * dx + dy * dy;
+                            // Check for collisions
+                            if (dd <= sBallDiameter2) {
+                                /*
+                                 * add a little bit of entropy, after nothing is
+                                 * perfect in the universe.
+                                 */
+                                dx += ((float) Math.random() - 0.5f) * 0.0001f;
+                                dy += ((float) Math.random() - 0.5f) * 0.0001f;
+                                dd = dx * dx + dy * dy;
+                                // simulate the spring
+                                final float d = (float) Math.sqrt(dd);
+                                final float c = (0.5f * (sBallDiameter - d)) / d;
+                                curr.mPosX -= dx * c;
+                                curr.mPosY -= dy * c;
+                                ball.mPosX += dx * c;
+                                ball.mPosY += dy * c;
+                                more = true;
+                            }
+                        }
+                        /*
+                         * Finally make sure the particle doesn't intersects
+                         * with the walls.
+                         */
+                        curr.resolveCollisionWithBounds();
+                    }
+                }
+            }
+
+            public int getParticleCount() {
+                return mBalls.length;
+            }
+
+            public float getPosX(int i) {
+                return mBalls[i].mPosX;
+            }
+
+            public float getPosY(int i) {
+                return mBalls[i].mPosY;
+            }
+        }
+
+        public void startSimulation() {
+            /*
+             * It is not necessary to get accelerometer events at a very high
+             * rate, by using a slower rate (SENSOR_DELAY_UI), we get an
+             * automatic low-pass filter, which "extracts" the gravity component
+             * of the acceleration. As an added benefit, we use less power and
+             * CPU resources.
+             */
+            mSensorManager.registerListener(this, mAccelerometer, SensorManager.SENSOR_DELAY_UI);
+        }
+
+        public void stopSimulation() {
+            mSensorManager.unregisterListener(this);
+        }
+
+        public SimulationView(Context context) {
+            super(context);
+            mAccelerometer = mSensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);
+
+            DisplayMetrics metrics = new DisplayMetrics();
+            getWindowManager().getDefaultDisplay().getMetrics(metrics);
+            mXDpi = metrics.xdpi;
+            mYDpi = metrics.ydpi;
+            mMetersToPixelsX = mXDpi / 0.0254f;
+            mMetersToPixelsY = mYDpi / 0.0254f;
+
+            // rescale the ball so it's about 0.5 cm on screen
+            Bitmap ball = BitmapFactory.decodeResource(getResources(), R.drawable.ball);
+            final int dstWidth = (int) (sBallDiameter * mMetersToPixelsX + 0.5f);
+            final int dstHeight = (int) (sBallDiameter * mMetersToPixelsY + 0.5f);
+            mBitmap = Bitmap.createScaledBitmap(ball, dstWidth, dstHeight, true);
+
+            Options opts = new Options();
+            opts.inDither = true;
+            opts.inPreferredConfig = Bitmap.Config.RGB_565;
+            mWood = BitmapFactory.decodeResource(getResources(), R.drawable.wood, opts);
+        }
+
+        @Override
+        protected void onSizeChanged(int w, int h, int oldw, int oldh) {
+            // compute the origin of the screen relative to the origin of
+            // the bitmap
+            mXOrigin = (w - mBitmap.getWidth()) * 0.5f;
+            mYOrigin = (h - mBitmap.getHeight()) * 0.5f;
+            mHorizontalBound = ((w / mMetersToPixelsX - sBallDiameter) * 0.5f);
+            mVerticalBound = ((h / mMetersToPixelsY - sBallDiameter) * 0.5f);
+        }
+
+        @Override
+        public void onSensorChanged(SensorEvent event) {
+            if (event.sensor.getType() != Sensor.TYPE_ACCELEROMETER)
+                return;
+            /*
+             * record the accelerometer data, the event's timestamp as well as
+             * the current time. The latter is needed so we can calculate the
+             * "present" time during rendering. In this application, we need to
+             * take into account how the screen is rotated with respect to the
+             * sensors (which always return data in a coordinate space aligned
+             * to with the screen in its native orientation).
+             */
+
+            switch (mDisplay.getRotation()) {
+                case Surface.ROTATION_0:
+                    mSensorX = event.values[0];
+                    mSensorY = event.values[1];
+                    break;
+                case Surface.ROTATION_90:
+                    mSensorX = -event.values[1];
+                    mSensorY = event.values[0];
+                    break;
+                case Surface.ROTATION_180:
+                    mSensorX = -event.values[0];
+                    mSensorY = -event.values[1];
+                    break;
+                case Surface.ROTATION_270:
+                    mSensorX = event.values[1];
+                    mSensorY = -event.values[0];
+                    break;
+            }
+
+            mSensorTimeStamp = event.timestamp;
+            mCpuTimeStamp = System.nanoTime();
+        }
+
+        @Override
+        protected void onDraw(Canvas canvas) {
+
+            /*
+             * draw the background
+             */
+
+            canvas.drawBitmap(mWood, 0, 0, null);
+
+            /*
+             * compute the new position of our object, based on accelerometer
+             * data and present time.
+             */
+
+            final ParticleSystem particleSystem = mParticleSystem;
+            final long now = mSensorTimeStamp + (System.nanoTime() - mCpuTimeStamp);
+            final float sx = mSensorX;
+            final float sy = mSensorY;
+
+            particleSystem.update(sx, sy, now);
+
+            final float xc = mXOrigin;
+            final float yc = mYOrigin;
+            final float xs = mMetersToPixelsX;
+            final float ys = mMetersToPixelsY;
+            final Bitmap bitmap = mBitmap;
+            final int count = particleSystem.getParticleCount();
+            for (int i = 0; i < count; i++) {
+                /*
+                 * We transform the canvas so that the coordinate system matches
+                 * the sensors coordinate system with the origin in the center
+                 * of the screen and the unit is the meter.
+                 */
+
+                final float x = xc + particleSystem.getPosX(i) * xs;
+                final float y = yc - particleSystem.getPosY(i) * ys;
+                canvas.drawBitmap(bitmap, x, y, null);
+            }
+
+            // and make sure to redraw asap
+            invalidate();
+        }
+
+        @Override
+        public void onAccuracyChanged(Sensor sensor, int accuracy) {
+        }
+    }
 }