Start by creating a new Forceometer project with a Forceometer Activity. Modify the main.xml layout resource to display two centered lines of large, bold text that will be used to display the current g-force and maximum observed g-force:

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
  android:orientation="vertical"
  android:layout_width="fill_parent"
  android:layout_height="fill_parent">
  <TextView android:id="@+id/acceleration"
    android:gravity="center"
    android:layout_width="fill_parent"
    android:layout_height="wrap_content"
    android:textStyle="bold"
    android:textSize="32sp"
    android:text="CENTER"
    android:editable="false"
    android:singleLine="true"
    android:layout_margin="10px"/>
  />
  <TextView android:id="@+id/maxAcceleration"
    android:gravity="center"
    android:layout_width="fill_parent"
    android:layout_height="wrap_content"
    android:textStyle="bold"
    android:textSize="40sp"
    android:text="CENTER"
    android:editable="false"
    android:singleLine="true"
    android:layout_margin="10px"/>
  />
</LinearLayout>

Within the Forceometer Activity, create instance variables to store references to both TextView Views and the SensorManager. Also create variables to record the last and maximum detected acceleration values:

SensorManager sensorManager;
TextView accelerationTextView;
TextView maxAccelerationTextView;
float currentAcceleration = 0;
float maxAcceleration = 0;

Create a new SensorEventListener implementation that sums the acceleration detected along each axis and negates the acceleration caused by gravity. It should update the current and maximum acceleration whenever a change in acceleration is detected:

private final SensorEventListener sensorEventListener = new SensorEventListener() {
  double calibration = SensorManager.STANDARD_GRAVITY;

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

  public void onSensorChanged(SensorEvent event) {
    double x = event.values[0];
    double y = event.values[1];
    double z = event.values[2];

    double a = Math.round(Math.sqrt(Math.pow(x, 2) +
                                    Math.pow(y, 2) +
                                    Math.pow(z, 2)));

currentAcceleration = Math.abs((float)(a-calibration));

    if (currentAcceleration > maxAcceleration)
      maxAcceleration = currentAcceleration;
  }
};

Update the onCreate method to register your new Listener for accelerometer updates using the SensorManager. Take the opportunity to get a reference to the two Text Views:

@Override
public void onCreate(Bundle savedInstanceState) {
  super.onCreate(savedInstanceState);
  setContentView(R.layout.main);

  accelerationTextView = (TextView)findViewById(R.id.acceleration);
  maxAccelerationTextView = (TextView)findViewById(R.id.maxAcceleration);
  sensorManager = (SensorManager)getSystemService(Context.SENSOR_SERVICE);

  Sensor accelerometer = sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);
  sensorManager.registerListener(sensorEventListener,
                                 accelerometer,
                                 SensorManager.SENSOR_DELAY_FASTEST);
}

The accelerometers can be very sensitive, so updating the Text Views for every detected acceleration change can be very expensive. Instead, create a new updateGUI method that synchronizes with the GUI thread based on a Timer before updating the Text Views:

private void updateGUI() {
  runOnUiThread(new Runnable() {
    public void run() {
      String currentG = currentAcceleration/SensorManager.STANDARD_GRAVITY
                        + "Gs";
      accelerationTextView.setText(currentG);
      accelerationTextView.invalidate();
      String maxG = maxAcceleration/SensorManager.STANDARD_GRAVITY + "Gs";
      maxAccelerationTextView.setText(maxG);
      maxAccelerationTextView.invalidate();
    }
  });
};

Finally, update the onCreate method to start a timer that's used to update the GUI every 100ms:

@Override
public void onCreate(Bundle savedInstanceState) {
  super.onCreate(savedInstanceState);
  setContentView(R.layout.main);
  accelerationTextView = (TextView)findViewById(R.id.acceleration);
  maxAccelerationTextView = (TextView)findViewById(R.id.maxAcceleration);
  sensorManager = (SensorManager)getSystemService(Context.SENSOR_SERVICE);

Sensor accelerometer =
    sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);
  sensorManager.registerListener(sensorEventListener,
                                 accelerometer,
                                 SensorManager.SENSOR_DELAY_FASTEST);

  Timer updateTimer = new Timer("gForceUpdate");
  updateTimer.scheduleAtFixedRate(new TimerTask() {
    public void run() {
      updateGUI();
    }
  }, 0, 100);
}

Open the Compass project you created in Chapter 4. You will be making changes to the CompassView as well as the Compass Activity used to display it. To ensure that the view and controller remain as decoupled as possible, the CompassView won't be linked to the Sensors directly; instead it will be updated by the Activity. Start by adding field variables and get/set methods for pitch and roll to the CompassView.

float pitch = 0;
float roll = 0;

public float getPitch() {
  return pitch;
}
public void setPitch(float pitch) {
  this.pitch = pitch;
}

public float getRoll() {
  return roll;
}
public void setRoll(float roll) {
  this.roll = roll;
}

Update the onDraw method to include two circles that will be used to indicate the pitch and roll values.

@Override
protected void onDraw(Canvas canvas) {

  [ ... Existing onDraw method ... ]

That completes the changes to the CompassView. If you run the application now it should appear as shown in Figure 14-4.

Figure 14-4. FIGURE 14-4

Now update the Compass Activity. Use the Sensor Manager to listen for orientation changes using the magnetic field and accelerometer Sensors. Start by adding local field variables to store the last magnetic field and accelerometer values, as well as references to the CompassView and SensorManager.

float[] aValues = new float[3];
float[] mValues = new float[3];
CompassView compassView;
SensorManager sensorManager;

Create a new updateOrientation method that uses new heading, pitch, and roll values to update the CompassView.

private void updateOrientation(float[] values) {
  if (compassView!= null) {
    compassView.setBearing(values[0]);
    compassView.setPitch(values[1]);
    compassView.setRoll(-values[2]);
    compassView.invalidate();
  }
}

Update the onCreate method to get references to the CompassView and SensorManager, and initialize the heading, pitch, and roll.

@Override
public void onCreate(Bundle savedInstanceState) {
  super.onCreate(savedInstanceState);
  setContentView(R.layout.main);

  compassView = (CompassView)this.findViewById(R.id.compassView);
  sensorManager = (SensorManager)getSystemService(Context.SENSOR_SERVICE);
  updateOrientation(new float[] {0, 0, 0});
}

Create a new calculateOrientation method to evaluate the device orientation using the last recorded accelerometer and magnetic field values.

private float[] calculateOrientation() {
  float[] values = new float[3];
  float[] R = new float[9];

  SensorManager.getRotationMatrix(R, null, aValues, mValues);
  SensorManager.getOrientation(R, values);

  // Convert from Radians to Degrees.
  values[0] = (float) Math.toDegrees(values[0]);
  values[1] = (float) Math.toDegrees(values[1]);
  values[2] = (float) Math.toDegrees(values[2]);

  return values;
}

Implement a SensorEventListener as a field variable. Within onSensorChanged it should check for the calling Sensor's type and update the last accelerometer or magnetic field values as appropriate before making a call to updateOrientation using the calculateOrientation method.

private final SensorEventListener sensorEventListener = new SensorEventListener() {

  public void onSensorChanged(SensorEvent event) {
    if (event.sensor.getType() == Sensor.TYPE_ACCELEROMETER)
      aValues = event.values;
    if (event.sensor.getType() == Sensor.TYPE_MAGNETIC_FIELD)
      mValues = event.values;

    updateOrientation(calculateOrientation());
  }

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

Now override onResume and onStop to register and unregister the SensorEventListener when the Activity becomes visible and hidden, respectively.

@Override
protected void onResume()
{
  super.onResume();

  Sensor accelerometer = sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);
  Sensor magField = sensorManager.getDefaultSensor(Sensor.TYPE_MAGNETIC_FIELD);

  sensorManager.registerListener(sensorEventListener,
                                 accelerometer,
                                 SensorManager.SENSOR_DELAY_FASTEST);
  sensorManager.registerListener(sensorEventListener,

magField,
                                 SensorManager.SENSOR_DELAY_FASTEST);
}

@Override
protected void onStop()
{
  sensorManager.unregisterListener(sensorEventListener);
  super.onStop();
}

If you run the application now you should see the three face dials update dynamically when the orientation of the device changes.

An artificial horizon is more useful if it's mounted vertically. Modify the reference frame of the artificial horizon to match this orientation by updating calculateOrientation to remap the coordinate system.

private float[] calculateOrientation() {
    float[] values = new float[3];
    float[] R = new float[9];
    float[] outR = new float[9];

    SensorManager.getRotationMatrix(R, null, aValues, mValues);
    SensorManager.remapCoordinateSystem(R,
                                        SensorManager.AXIS_X,
                                        SensorManager.AXIS_Z,
                                        outR);

    SensorManager.getOrientation(outR, values);

    // Convert from Radians to Degrees.
    values[0] = (float) Math.toDegrees(values[0]);
    values[1] = (float) Math.toDegrees(values[1]);
    values[2] = (float) Math.toDegrees(values[2]);

    return values;
  }