LineageOS/android_development
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Reformat to Android style guidelines

Browse Source 
Change-Id: Ib9d7e39464a246dbaae38e00fbb325f153f89f65
This commit is contained in:
Mathias Agopian
2010-08-16 16:13:24 -07:00
parent a7c85d9235
commit a37be42f9f
1 changed files with 358 additions and 381 deletions
Download Patch File Download Diff File Expand all files Collapse all files

739
samples/AccelerometerPlay/src/com/example/android/accelerometerplay/AccelerometerPlayActivity.java
View File

@@ -49,435 +49,412 @@ import android.view.WindowManager;
public class AccelerometerPlayActivity extends Activity { public class AccelerometerPlayActivity extends Activity {
private SimulationView mSimulationView; private SimulationView mSimulationView;
private SensorManager mSensorManager; private SensorManager mSensorManager;
private PowerManager mPowerManager; private PowerManager mPowerManager;
private WindowManager mWindowManager; private WindowManager mWindowManager;
private Display mDisplay; private Display mDisplay;
private WakeLock mWakeLock; private WakeLock mWakeLock;
/** Called when the activity is first created. */ /** Called when the activity is first created. */
@Override @Override
public void onCreate(Bundle savedInstanceState) { public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState); super.onCreate(savedInstanceState);
// Get an instance of the SensorManager // Get an instance of the SensorManager
mSensorManager = (SensorManager) getSystemService(SENSOR_SERVICE); mSensorManager = (SensorManager) getSystemService(SENSOR_SERVICE);
// Get an instance of the PowerManager // Get an instance of the PowerManager
mPowerManager = (PowerManager) getSystemService(POWER_SERVICE); mPowerManager = (PowerManager) getSystemService(POWER_SERVICE);
// Get an instance of the WindowManager // Get an instance of the WindowManager
mWindowManager = (WindowManager) getSystemService(WINDOW_SERVICE); mWindowManager = (WindowManager) getSystemService(WINDOW_SERVICE);
mDisplay = mWindowManager.getDefaultDisplay(); mDisplay = mWindowManager.getDefaultDisplay();
// Create a bright wake lock // Create a bright wake lock
mWakeLock = mPowerManager.newWakeLock( mWakeLock = mPowerManager.newWakeLock(PowerManager.SCREEN_BRIGHT_WAKE_LOCK, getClass()
PowerManager.SCREEN_BRIGHT_WAKE_LOCK, getClass().getName()); .getName());
// instantiate our simulation view and set it as the activity's content // instantiate our simulation view and set it as the activity's content
mSimulationView = new SimulationView(this); mSimulationView = new SimulationView(this);
setContentView(mSimulationView); setContentView(mSimulationView);
} }
@Override @Override
protected void onResume() { protected void onResume() {
super.onResume(); super.onResume();
/* /*
* when the activity is resumed, we acquire a wake-lock so that the * 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 stays on, since the user will likely not be fiddling with the
* screen or buttons. * screen or buttons.
*/ */
mWakeLock.acquire(); mWakeLock.acquire();
// Start the simulation // Start the simulation
mSimulationView.startSimulation(); mSimulationView.startSimulation();
} }
@Override @Override
protected void onPause() { protected void onPause() {
super.onPause(); super.onPause();
/* /*
* When the activity is paused, we make sure to stop the simulation, * When the activity is paused, we make sure to stop the simulation,
* release our sensor resources and wake locks * release our sensor resources and wake locks
*/ */
// Stop the simulation // Stop the simulation
mSimulationView.stopSimulation(); mSimulationView.stopSimulation();
// and release our wake-lock // and release our wake-lock
mWakeLock.release(); mWakeLock.release();
} }
class SimulationView extends View implements SensorEventListener { class SimulationView extends View implements SensorEventListener {
// diameter of the balls in meters // diameter of the balls in meters
private static final float sBallDiameter = 0.004f; private static final float sBallDiameter = 0.004f;
private static final float sBallDiameter2 = sBallDiameter private static final float sBallDiameter2 = sBallDiameter * sBallDiameter;
* sBallDiameter;
// friction of the virtual table and air // friction of the virtual table and air
private static final float sFriction = 0.1f; private static final float sFriction = 0.1f;
private Sensor mAccelerometer; private Sensor mAccelerometer;
private long mLastT; private long mLastT;
private float mLastDeltaT; private float mLastDeltaT;
private float mXDpi; private float mXDpi;
private float mYDpi; private float mYDpi;
private float mMetersToPixelsX; private float mMetersToPixelsX;
private float mMetersToPixelsY; private float mMetersToPixelsY;
private Bitmap mBitmap; private Bitmap mBitmap;
private Bitmap mWood; private Bitmap mWood;
private float mXOrigin; private float mXOrigin;
private float mYOrigin; private float mYOrigin;
private float mSensorX; private float mSensorX;
private float mSensorY; private float mSensorY;
private long mSensorTimeStamp; private long mSensorTimeStamp;
private long mCpuTimeStamp; private long mCpuTimeStamp;
private float mHorizontalBound; private float mHorizontalBound;
private float mVerticalBound; private float mVerticalBound;
private final ParticleSystem mParticleSystem = new ParticleSystem(); private final ParticleSystem mParticleSystem = new ParticleSystem();
/* /*
* Each of our particle holds its previous and current position, its * Each of our particle holds its previous and current position, its
* acceleration. for added realism each particle has its own friction * acceleration. for added realism each particle has its own friction
* coefficient. * coefficient.
*/ */
class Particle { class Particle {
private float mPosX; private float mPosX;
private float mPosY; private float mPosY;
private float mAccelX; private float mAccelX;
private float mAccelY; private float mAccelY;
private float mLastPosX; private float mLastPosX;
private float mLastPosY; private float mLastPosY;
private float mOneMinusFriction; private float mOneMinusFriction;
Particle() { Particle() {
// make each particle a bit different by randomizing its // make each particle a bit different by randomizing its
// coefficient of friction // coefficient of friction
final float r = ((float) Math.random() - 0.5f) * 0.2f; final float r = ((float) Math.random() - 0.5f) * 0.2f;
mOneMinusFriction = 1.0f - sFriction + r; mOneMinusFriction = 1.0f - sFriction + r;
} }
public void computePhysics(float sx, float sy, float dT, float dTC) { public void computePhysics(float sx, float sy, float dT, float dTC) {
// Force of gravity applied to our virtual object // Force of gravity applied to our virtual object
final float m = 1000.0f; // mass of our virtual object final float m = 1000.0f; // mass of our virtual object
final float gx = -sx * m; final float gx = -sx * m;
final float gy = -sy * m; final float gy = -sy * m;
/* /*
* <20>F = mA <=> A = <20>F / m * <20>F = mA <=> A = <20>F / m We could simplify the code by
* * completely eliminating "m" (the mass) from all the equations,
* We could simplify the code by completely eliminating "m" (the * but it would hide the concepts from this sample code.
* 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 invm = 1.0f / m; final float ay = gy * invm;
final float ax = gx * invm;
final float ay = gy * invm;
/* /*
* Time-corrected Verlet integration * Time-corrected Verlet integration The position Verlet
* * integrator is defined as x(t+<2B>t) = x(t) + x(t) - x(t-<2D>t) +
* The position Verlet integrator is defined as * a(t)<29>t<EFBFBD>2 However, the above equation doesn't handle variable
* * <20>t very well, a time-corrected version is needed: x(t+<2B>t) =
* x(t+<2B>t) = x(t) + x(t) - x(t-<2D>t) + a(t)<29>t<EFBFBD>2 * x(t) + (x(t) - x(t-<2D>t)) * (<28>t/<2F>t_prev) + a(t)<29>t<EFBFBD>2 We also add
* * a simple friction term (f) to the equation: x(t+<2B>t) = x(t) +
* However, the above equation doesn't handle variable <20>t very * (1-f) * (x(t) - x(t-<2D>t)) * (<28>t/<2F>t_prev) + a(t)<29>t<EFBFBD>2
* well, a time-corrected version is needed: */
* final float dTdT = dT * dT;
* x(t+<2B>t) = x(t) + (x(t) - x(t-<2D>t)) * (<28>t/<2F>t_prev) + a(t)<29>t<EFBFBD>2 final float x = mPosX + mOneMinusFriction * dTC * (mPosX - mLastPosX) + mAccelX
* * dTdT;
* final float y = mPosY + mOneMinusFriction * dTC * (mPosY - mLastPosY) + mAccelY
* We also add a simple friction term (f) to the equation: * dTdT;
* mLastPosX = mPosX;
* x(t+<2B>t) = x(t) + (1-f) * (x(t) - x(t-<2D>t)) * (<28>t/<2F>t_prev) + mLastPosY = mPosY;
* a(t)<29>t<EFBFBD>2 mPosX = x;
*/ mPosY = y;
final float dTdT = dT * dT; mAccelX = ax;
final float x = mPosX + mOneMinusFriction * dTC mAccelY = ay;
* (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 * Resolving constraints and collisions with the Verlet integrator
* can be very simple, we simply need to move a colliding or * can be very simple, we simply need to move a colliding or
* constrained particle in such way that the constraint is * constrained particle in such way that the constraint is
* satisfied. * satisfied.
*/ */
public void resolveCollisionWithBounds() { public void resolveCollisionWithBounds() {
final float xmax = mHorizontalBound; final float xmax = mHorizontalBound;
final float ymax = mVerticalBound; final float ymax = mVerticalBound;
final float x = mPosX; final float x = mPosX;
final float y = mPosY; final float y = mPosY;
if (x > xmax) { if (x > xmax) {
mPosX = xmax; mPosX = xmax;
} else if (x < -xmax) { } else if (x < -xmax) {
mPosX = -xmax; mPosX = -xmax;
} }
if (y > ymax) { if (y > ymax) {
mPosY = ymax; mPosY = ymax;
} else if (y < -ymax) { } else if (y < -ymax) {
mPosY = -ymax; mPosY = -ymax;
} }
} }
} }
/* /*
* A particle system is just a collection of particles * A particle system is just a collection of particles
*/ */
class ParticleSystem { class ParticleSystem {
static final int NUM_PARTICLES = 15; static final int NUM_PARTICLES = 15;
private Particle mBalls[] = new Particle[NUM_PARTICLES]; private Particle mBalls[] = new Particle[NUM_PARTICLES];
ParticleSystem() { ParticleSystem() {
/* /*
* Initially our particles have no speed or acceleration * Initially our particles have no speed or acceleration
*/ */
for (int i = 0; i < mBalls.length; i++) { for (int i = 0; i < mBalls.length; i++) {
mBalls[i] = new Particle(); mBalls[i] = new Particle();
} }
} }
/* /*
* Update the position of each particle in the system using the * Update the position of each particle in the system using the
* Verlet integrator. * Verlet integrator.
*/ */
private void updatePositions(float sx, float sy, long timestamp) { private void updatePositions(float sx, float sy, long timestamp) {
final long t = timestamp; final long t = timestamp;
if (mLastT != 0) { if (mLastT != 0) {
final float dT = (float) (t - mLastT) final float dT = (float) (t - mLastT) * (1.0f / 1000000000.0f);
* (1.0f / 1000000000.0f); if (mLastDeltaT != 0) {
if (mLastDeltaT != 0) { final float dTC = dT / mLastDeltaT;
final float dTC = dT / mLastDeltaT; final int count = mBalls.length;
final int count = mBalls.length; for (int i = 0; i < count; i++) {
for (int i = 0; i < count; i++) { Particle ball = mBalls[i];
Particle ball = mBalls[i]; ball.computePhysics(sx, sy, dT, dTC);
ball.computePhysics(sx, sy, dT, dTC); }
} }
} mLastDeltaT = dT;
mLastDeltaT = dT; }
} mLastT = t;
mLastT = t; }
}
/* /*
* Performs one iteration of the simulation. First updating the * Performs one iteration of the simulation. First updating the
* position of all the particles and resolving the constraints and * position of all the particles and resolving the constraints and
* collisions. * collisions.
*/ */
public void update(float sx, float sy, long now) { public void update(float sx, float sy, long now) {
// update the system's positions // update the system's positions
updatePositions(sx, sy, now); updatePositions(sx, sy, now);
// We do no more than a limited number of iterations // We do no more than a limited number of iterations
final int NUM_MAX_ITERATIONS = 10; final int NUM_MAX_ITERATIONS = 10;
/* /*
* Resolve collisions, each particle is tested against every * Resolve collisions, each particle is tested against every
* other particle for collision. If a collision is detected the * other particle for collision. If a collision is detected the
* particle is moved away using a virtual spring of infinite * particle is moved away using a virtual spring of infinite
* stiffness. * stiffness.
*/ */
boolean more = true; boolean more = true;
final int count = mBalls.length; final int count = mBalls.length;
for (int k = 0; k < NUM_MAX_ITERATIONS && more; k++) { for (int k = 0; k < NUM_MAX_ITERATIONS && more; k++) {
more = false; more = false;
for (int i = 0; i < count; i++) { for (int i = 0; i < count; i++) {
Particle curr = mBalls[i]; Particle curr = mBalls[i];
for (int j = i + 1; j < count; j++) { for (int j = i + 1; j < count; j++) {
Particle ball = mBalls[j]; Particle ball = mBalls[j];
float dx = ball.mPosX - curr.mPosX; float dx = ball.mPosX - curr.mPosX;
float dy = ball.mPosY - curr.mPosY; float dy = ball.mPosY - curr.mPosY;
float dd = dx * dx + dy * dy; float dd = dx * dx + dy * dy;
// Check for collisions // Check for collisions
if (dd <= sBallDiameter2) { if (dd <= sBallDiameter2) {
/* /*
* add a little bit of entropy, after nothing is * add a little bit of entropy, after nothing is
* perfect in the universe. * perfect in the universe.
*/ */
dx += ((float) Math.random() - 0.5f) * 0.0001f; dx += ((float) Math.random() - 0.5f) * 0.0001f;
dy += ((float) Math.random() - 0.5f) * 0.0001f; dy += ((float) Math.random() - 0.5f) * 0.0001f;
dd = dx * dx + dy * dy; dd = dx * dx + dy * dy;
// simulate the spring // simulate the spring
final float d = (float) Math.sqrt(dd); final float d = (float) Math.sqrt(dd);
final float c = (0.5f * (sBallDiameter - d)) final float c = (0.5f * (sBallDiameter - d)) / d;
/ d; curr.mPosX -= dx * c;
curr.mPosX -= dx * c; curr.mPosY -= dy * c;
curr.mPosY -= dy * c; ball.mPosX += dx * c;
ball.mPosX += dx * c; ball.mPosY += dy * c;
ball.mPosY += dy * c; more = true;
more = true; }
} }
} /*
/* * Finally make sure the particle doesn't intersects
* Finally make sure the particle doesn't intersects * with the walls.
* with the walls. */
*/ curr.resolveCollisionWithBounds();
curr.resolveCollisionWithBounds(); }
} }
} }
}
public int getParticleCount() { public int getParticleCount() {
return mBalls.length; return mBalls.length;
} }
public float getPosX(int i) { public float getPosX(int i) {
return mBalls[i].mPosX; return mBalls[i].mPosX;
} }
public float getPosY(int i) { public float getPosY(int i) {
return mBalls[i].mPosY; return mBalls[i].mPosY;
} }
} }
public void startSimulation() { public void startSimulation() {
/* /*
* It is not necessary to get accelerometer events at a very high * It is not necessary to get accelerometer events at a very high
* rate, by using a slower rate (SENSOR_DELAY_UI), we get an * rate, by using a slower rate (SENSOR_DELAY_UI), we get an
* automatic low-pass filter, which "extracts" the gravity component * automatic low-pass filter, which "extracts" the gravity component
* of the acceleration. As an added benefit, we use less power and * of the acceleration. As an added benefit, we use less power and
* CPU resources. * CPU resources.
*/ */
mSensorManager.registerListener(this, mAccelerometer, mSensorManager.registerListener(this, mAccelerometer, SensorManager.SENSOR_DELAY_UI);
SensorManager.SENSOR_DELAY_UI); }
}
public void stopSimulation() { public void stopSimulation() {
mSensorManager.unregisterListener(this); mSensorManager.unregisterListener(this);
} }
public SimulationView(Context context) { public SimulationView(Context context) {
super(context); super(context);
mAccelerometer = mSensorManager mAccelerometer = mSensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);
.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);
DisplayMetrics metrics = new DisplayMetrics(); DisplayMetrics metrics = new DisplayMetrics();
getWindowManager().getDefaultDisplay().getMetrics(metrics); getWindowManager().getDefaultDisplay().getMetrics(metrics);
mXDpi = metrics.xdpi; mXDpi = metrics.xdpi;
mYDpi = metrics.ydpi; mYDpi = metrics.ydpi;
mMetersToPixelsX = mXDpi / 0.0254f; mMetersToPixelsX = mXDpi / 0.0254f;
mMetersToPixelsY = mYDpi / 0.0254f; mMetersToPixelsY = mYDpi / 0.0254f;
// rescale the ball so it's about 0.5 cm on screen // rescale the ball so it's about 0.5 cm on screen
Bitmap ball = BitmapFactory.decodeResource(getResources(), Bitmap ball = BitmapFactory.decodeResource(getResources(), R.drawable.ball);
R.drawable.ball); final int dstWidth = (int) (sBallDiameter * mMetersToPixelsX + 0.5f);
final int dstWidth = (int) (sBallDiameter * mMetersToPixelsX + 0.5f); final int dstHeight = (int) (sBallDiameter * mMetersToPixelsY + 0.5f);
final int dstHeight = (int) (sBallDiameter * mMetersToPixelsY + 0.5f); mBitmap = Bitmap.createScaledBitmap(ball, dstWidth, dstHeight, true);
mBitmap = Bitmap
.createScaledBitmap(ball, dstWidth, dstHeight, true);
Options opts = new Options(); Options opts = new Options();
opts.inDither = true; opts.inDither = true;
opts.inPreferredConfig = Bitmap.Config.RGB_565; opts.inPreferredConfig = Bitmap.Config.RGB_565;
mWood = BitmapFactory.decodeResource(getResources(), mWood = BitmapFactory.decodeResource(getResources(), R.drawable.wood, opts);
R.drawable.wood, opts); }
}
@Override @Override
protected void onSizeChanged(int w, int h, int oldw, int oldh) { protected void onSizeChanged(int w, int h, int oldw, int oldh) {
// compute the origin of the screen relative to the origin of // compute the origin of the screen relative to the origin of
// the bitmap // the bitmap
mXOrigin = (w - mBitmap.getWidth()) * 0.5f; mXOrigin = (w - mBitmap.getWidth()) * 0.5f;
mYOrigin = (h - mBitmap.getHeight()) * 0.5f; mYOrigin = (h - mBitmap.getHeight()) * 0.5f;
mHorizontalBound = ((w / mMetersToPixelsX - sBallDiameter) * 0.5f); mHorizontalBound = ((w / mMetersToPixelsX - sBallDiameter) * 0.5f);
mVerticalBound = ((h / mMetersToPixelsY - sBallDiameter) * 0.5f); mVerticalBound = ((h / mMetersToPixelsY - sBallDiameter) * 0.5f);
} }
@Override @Override
public void onSensorChanged(SensorEvent event) { public void onSensorChanged(SensorEvent event) {
if (event.sensor.getType() != Sensor.TYPE_ACCELEROMETER) if (event.sensor.getType() != Sensor.TYPE_ACCELEROMETER)
return; return;
/* /*
* record the accelerometer data, the event's timestamp as well as * record the accelerometer data, the event's timestamp as well as
* the current time. The latter is needed so we can calculate the * the current time. The latter is needed so we can calculate the
* "present" time during rendering. * "present" time during rendering. In this application, we need to
* * take into account how the screen is rotated with respect to the
* In this application, we need to take into account how the * sensors (which always return data in a coordinate space aligned
* screen is rotated with respect to the sensors (which always * to with the screen in its native orientation).
* return data in a coordinate space aligned to with the screen */
* in its native orientation).
*
*/
switch (mDisplay.getRotation()) { switch (mDisplay.getRotation()) {
case Surface.ROTATION_0: case Surface.ROTATION_0:
mSensorX = event.values[0]; mSensorX = event.values[0];
mSensorY = event.values[1]; mSensorY = event.values[1];
break; break;
case Surface.ROTATION_90: case Surface.ROTATION_90:
mSensorX = -event.values[1]; mSensorX = -event.values[1];
mSensorY = event.values[0]; mSensorY = event.values[0];
break; break;
case Surface.ROTATION_180: case Surface.ROTATION_180:
mSensorX = -event.values[0]; mSensorX = -event.values[0];
mSensorY = -event.values[1]; mSensorY = -event.values[1];
break; break;
case Surface.ROTATION_270: case Surface.ROTATION_270:
mSensorX = event.values[1]; mSensorX = event.values[1];
mSensorY = -event.values[0]; mSensorY = -event.values[0];
break; break;
} }
mSensorTimeStamp = event.timestamp; mSensorTimeStamp = event.timestamp;
mCpuTimeStamp = System.nanoTime(); mCpuTimeStamp = System.nanoTime();
} }
@Override @Override
protected void onDraw(Canvas canvas) { protected void onDraw(Canvas canvas) {
/* /*
* draw the background * draw the background
*/ */
canvas.drawBitmap(mWood, 0, 0, null); canvas.drawBitmap(mWood, 0, 0, null);
/* /*
* compute the new position of our object, based on accelerometer * compute the new position of our object, based on accelerometer
* data and present time. * data and present time.
*/ */
final ParticleSystem particleSystem = mParticleSystem; final ParticleSystem particleSystem = mParticleSystem;
final long now = mSensorTimeStamp final long now = mSensorTimeStamp + (System.nanoTime() - mCpuTimeStamp);
+ (System.nanoTime() - mCpuTimeStamp); final float sx = mSensorX;
final float sx = mSensorX; final float sy = mSensorY;
final float sy = mSensorY;
particleSystem.update(sx, sy, now); particleSystem.update(sx, sy, now);
final float xc = mXOrigin; final float xc = mXOrigin;
final float yc = mYOrigin; final float yc = mYOrigin;
final float xs = mMetersToPixelsX; final float xs = mMetersToPixelsX;
final float ys = mMetersToPixelsY; final float ys = mMetersToPixelsY;
final Bitmap bitmap = mBitmap; final Bitmap bitmap = mBitmap;
final int count = particleSystem.getParticleCount(); final int count = particleSystem.getParticleCount();
for (int i = 0; i < count; i++) { for (int i = 0; i < count; i++) {
/* /*
* We transform the canvas so that the coordinate system matches * We transform the canvas so that the coordinate system matches
* the sensors coordinate system with the origin in the center * the sensors coordinate system with the origin in the center
* of the screen and the unit is the meter. * of the screen and the unit is the meter.
*/ */
final float x = xc + particleSystem.getPosX(i) * xs; final float x = xc + particleSystem.getPosX(i) * xs;
final float y = yc - particleSystem.getPosY(i) * ys; final float y = yc - particleSystem.getPosY(i) * ys;
canvas.drawBitmap(bitmap, x, y, null); canvas.drawBitmap(bitmap, x, y, null);
} }
// and make sure to redraw asap // and make sure to redraw asap
invalidate(); invalidate();
} }
@Override @Override
public void onAccuracyChanged(Sensor sensor, int accuracy) { public void onAccuracyChanged(Sensor sensor, int accuracy) {
} }
} }
} }