本文将介绍运动传感器（Motion Sensors）、位置传感器（Position Sensors）、环境传感器（Environment Sensors）。

如需访问官方原文，您可以点击这些链接：

• 《Motion Sensors》
• 《Position Sensors》
• 《Environment Sensors》

运动传感器（Motion Sensors）

Android传感器开源项目（Android Open Source Project Sensors）

Android传感器开源项目（Android Open Source Project Sensors，简称AOSP）提供了三种软件驱动型的传感器。分别是：重力传感器、线性加速器 和 旋转向量传感器。这些传感器支持Android 4.0及以上版本，并提供了更高的稳定性。

使用加速器（Using the Accelerometer）

private SensorManager mSensorManager;
private Sensor mSensor;
  ...
mSensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
mSensor = mSensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);

Ad = - ∑Fs / mass

Ad = -g - ∑F / mass

具体方式如下：

public void onSensorChanged(SensorEvent event){
  // In this example, alpha is calculated as t / (t + dT),
  // where t is the low-pass filter‘s time-constant and
  // dT is the event delivery rate.

  final float alpha = 0.8;

  // Isolate the force of gravity with the low-pass filter.
  gravity[0] = alpha * gravity[0] + (1 - alpha) * event.values[0];
  gravity[1] = alpha * gravity[1] + (1 - alpha) * event.values[1];
  gravity[2] = alpha * gravity[2] + (1 - alpha) * event.values[2];

  // Remove the gravity contribution with the high-pass filter.
  linear_acceleration[0] = event.values[0] - gravity[0];
  linear_acceleration[1] = event.values[1] - gravity[1];
  linear_acceleration[2] = event.values[2] - gravity[2];
}

当设备放在水平桌面时：

• 从左向右移动设备，则x方向的加速度为正值；
• 从底部向顶部移动设备，则y方向的加速度为正值；
• 从下向上以加速度A的大小抛出设备时，则z方向的加速度为A+9.81，那么设备的相对加速度为A - 9.81。（排除重力加速度的影响）
• 设备静止时垂直地面方向的相对加速度为-9.81 m/s2。（排除重力加速度的影响）

使用重力传感器（Using the Gravity Sensor）

private SensorManager mSensorManager;
private Sensor mSensor;
...
mSensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
mSensor = mSensorManager.getDefaultSensor(Sensor.TYPE_GRAVITY);

使用陀螺仪（Using the Gyroscope）

private SensorManager mSensorManager;
private Sensor mSensor;
...
mSensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
mSensor = mSensorManager.getDefaultSensor(Sensor.TYPE_GYROSCOPE);

// Create a constant to convert nanoseconds to seconds.
private static final float NS2S = 1.0f / 1000000000.0f;
private final float[] deltaRotationVector = new float[4]();
private float timestamp;

public void onSensorChanged(SensorEvent event) {
  // This timestep‘s delta rotation to be multiplied by the current rotation
  // after computing it from the gyro sample data.
  if (timestamp != 0) {
    final float dT = (event.timestamp - timestamp) * NS2S;
    // Axis of the rotation sample, not normalized yet.
    float axisX = event.values[0];
    float axisY = event.values[1];
    float axisZ = event.values[2];

    // Calculate the angular speed of the sample
    float omegaMagnitude = sqrt(axisX*axisX + axisY*axisY + axisZ*axisZ);

    // Normalize the rotation vector if it‘s big enough to get the axis
    // (that is, EPSILON should represent your maximum allowable margin of error)
    if (omegaMagnitude > EPSILON) {
      axisX /= omegaMagnitude;
      axisY /= omegaMagnitude;
      axisZ /= omegaMagnitude;
    }

    // Integrate around this axis with the angular speed by the timestep
    // in order to get a delta rotation from this sample over the timestep
    // We will convert this axis-angle representation of the delta rotation
    // into a quaternion before turning it into the rotation matrix.
    float thetaOverTwo = omegaMagnitude * dT / 2.0f;
    float sinThetaOverTwo = sin(thetaOverTwo);
    float cosThetaOverTwo = cos(thetaOverTwo);
    deltaRotationVector[0] = sinThetaOverTwo * axisX;
    deltaRotationVector[1] = sinThetaOverTwo * axisY;
    deltaRotationVector[2] = sinThetaOverTwo * axisZ;
    deltaRotationVector[3] = cosThetaOverTwo;
  }
  timestamp = event.timestamp;
  float[] deltaRotationMatrix = new float[9];
  SensorManager.getRotationMatrixFromVector(deltaRotationMatrix, deltaRotationVector);
    // User code should concatenate the delta rotation we computed with the current rotation
    // in order to get the updated rotation.
    // rotationCurrent = rotationCurrent * deltaRotationMatrix;
   }
}

位置传感器（Position Sensors）

计算设备的方向（Computing the Device’s Orientation）

下面的代码演示了如何检测设备的朝向：

private SensorManager mSensorManager;
...
// Rotation matrix based on current readings from accelerometer and magnetometer.
final float[] rotationMatrix = new float[9];
mSensorManager.getRotationMatrix(rotationMatrix, null,
  accelerometerReading, magnetometerReading);

// Express the updated rotation matrix as three orientation angles.
final float[] orientationAngles = new float[3];
mSensorManager.getOrientation(rotationMatrix, orientationAngles);

获得的结果如下：

• 方位角（Azimuth ）：与z轴负方向的夹角。即手机的罗盘方向与北极点的夹角（ This is the angle between the device’s current compass direction and magnetic north. If the top edge of the device faces magnetic north）。如果设备的顶部朝向正北，则该角度为0；若朝向正南，角度为180；朝向正东，为90度；正西为270度
• 倾斜角（Pitch ）：与x轴正方向的夹角。即手机屏幕的平行线与地面的平行线的夹角（ This is the angle between a plane parallel to the device’s screen and a plane parallel to the ground）。若将设备水平拿在手上，并将设备尾部朝向自己，这时若将设备旋转：头部慢慢朝向地面，此时该角度将成为正值，即0到90度（If you hold the device parallel to the ground with the bottom edge closest to you and tilt the top edge of the device toward the ground, the pitch angle becomes positive）。相反，若将头部慢慢朝向天空，此时将变为负值，即0到-90度。该角度的范围是-180到+180度。
• 滚动角（Roll ）：与y轴正方向的夹角。即手机屏幕的垂线与地面垂线的夹角（This is the angle between a plane perpendicular to the device’s screen and a plane perpendicular to the ground）。若将设备水平拿在手上，并将设备尾部朝向自己，这时若将设备旋转：左侧慢慢朝向地面，此时该角度将成为正值，即0到90度。若是右侧慢慢朝向地面，此时该角度将成为负值，即0到-90度。该角度的变化为-90度到+90度。

public class SensorActivity extends Activity implements SensorEventListener {

  private SensorManager mSensorManager;
  private final float[] mAccelerometerReading = new float[3];
  private final float[] mMagnetometerReading = new float[3];

  private final float[] mRotationMatrix = new float[9];
  private final float[] mOrientationAngles = new float[3];

  @Override
  public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.main);
    mSensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
  }

  @Override
  public void onAccuracyChanged(Sensor sensor, int accuracy) {
    // Do something here if sensor accuracy changes.
    // You must implement this callback in your code.
  }

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

    // Get updates from the accelerometer and magnetometer at a constant rate.
    // To make batch operations more efficient and reduce power consumption,
    // provide support for delaying updates to the application.
    //
    // In this example, the sensor reporting delay is small enough such that
    // the application receives an update before the system checks the sensor
    // readings again.
    mSensorManager.registerListener(this, Sensor.TYPE_ACCELEROMETER,
      SensorManager.SENSOR_DELAY_NORMAL, SensorManager.SENSOR_DELAY_UI);
    mSensorManager.registerListener(this, Sensor.TYPE_MAGNETIC_FIELD,
      SensorManager.SENSOR_DELAY_NORMAL, SensorManager.SENSOR_DELAY_UI);
  }

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

    // Don‘t receive any more updates from either sensor.
    mSensorManager.unregisterListener(this);
  }

  // Get readings from accelerometer and magnetometer. To simplify calculations,
  // consider storing these readings as unit vectors.
  @Override
  public void onSensorChanged(SensorEvent event) {
    if (event.sensor == Sensor.TYPE_ACCELEROMETER) {
      System.arraycopy(event.values, 0, mAccelerometerReading,
        0, mAccelerometerReading.length);
    }
    else if (event.sensor == Sensor.TYPE_MAGNETIC_FIELD) {
      System.arraycopy(event.values, 0, mMagnetometerReading,
        0, mMagnetometerReading.length);
    }
  }

  // Compute the three orientation angles based on the most recent readings from
  // the device‘s accelerometer and magnetometer.
  public void updateOrientationAngles() {
    // Update rotation matrix, which is needed to update orientation angles.
    mSensorManager.getRotationMatrix(mRotationMatrix, null,
      mAccelerometerReading, mMagnetometerReading);

    // "mRotationMatrix" now has up-to-date information.

    mSensorManager.getOrientation(mRotationMatrix, mOrientationAngles);

    // "mOrientationAngles" now has up-to-date information.
  }
}

使用接近度传感器（Using the Proximity Sensor）

获取接近度传感器实例的方式如下：

private SensorManager mSensorManager;
private Sensor mSensor;
...
mSensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
mSensor = mSensorManager.getDefaultSensor(Sensor.TYPE_PROXIMITY);

该传感器通常用于监测用户打电话时，耳朵距离设备的距离。大部分接近度传感器会返回距离的绝对值，单位是cm，而少数传感器仅会返回代表距离物体远近的boolean值。下面的例子演示了如何应用该传感器：

public class SensorActivity extends Activity implements SensorEventListener {
  private SensorManager mSensorManager;
  private Sensor mProximity;

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

    // Get an instance of the sensor service, and use that to get an instance of
    // a particular sensor.
    mSensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
    mProximity = mSensorManager.getDefaultSensor(Sensor.TYPE_PROXIMITY);
  }

  @Override
  public final void onAccuracyChanged(Sensor sensor, int accuracy) {
    // Do something here if sensor accuracy changes.
  }

  @Override
  public final void onSensorChanged(SensorEvent event) {
    float distance = event.values[0];
    // Do something with this sensor data.
  }

  @Override
  protected void onResume() {
    // Register a listener for the sensor.
    super.onResume();
    mSensorManager.registerListener(this, mProximity, SensorManager.SENSOR_DELAY_NORMAL);
  }

  @Override
  protected void onPause() {
    // Be sure to unregister the sensor when the activity pauses.
    super.onPause();
    mSensorManager.unregisterListener(this);
  }
}

环境传感器（Environment Sensors）

与其他传感器不同的是，环境传感器并不返回一组数据，而且没有低通和高通滤波器，如下表所示：

使用光线、压力和温度传感器（Using the Light, Pressure, and Temperature Sensors）

示例如下：

public class SensorActivity extends Activity implements SensorEventListener {
  private SensorManager mSensorManager;
  private Sensor mPressure;

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

    // Get an instance of the sensor service, and use that to get an instance of
    // a particular sensor.
    mSensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
    mPressure = mSensorManager.getDefaultSensor(Sensor.TYPE_PRESSURE);
  }

  @Override
  public final void onAccuracyChanged(Sensor sensor, int accuracy) {
    // Do something here if sensor accuracy changes.
  }

  @Override
  public final void onSensorChanged(SensorEvent event) {
    float millibars_of_pressure = event.values[0];
    // Do something with this sensor data.
  }

  @Override
  protected void onResume() {
    // Register a listener for the sensor.
    super.onResume();
    mSensorManager.registerListener(this, mPressure, SensorManager.SENSOR_DELAY_NORMAL);
  }

  @Override
  protected void onPause() {
    // Be sure to unregister the sensor when the activity pauses.
    super.onPause();
    mSensorManager.unregisterListener(this);
  }
}

使用湿度传感器（Using the Humidity Sensor）

使用湿度传感器与光照传感器 等环境传感器的方式一致。若您的设备上同时包含了湿度传感器与温度传感器，那么可以利用这两个传感器返回的值计算露点（Dew point）和绝对湿度（ absolute humidity）：

• 露点（Dew point）：露点，也称冷凝点，表示水蒸气冷凝成液态水所需要的温度。露点的计算公式如下：

  

其中：

• td表示露点温度，单位是摄氏度；
• t表示当前温度，单位是摄氏度；
• RH表示相对湿度，值为百分比形式（%）；
• m = 17.62；
• Tn = 243.12；

• 绝对湿度（Absolute humidity）：表示标准状态下(760mmHg)每立方米湿空气中所含水蒸汽的重量。绝对湿度的计算公式如下：

  

其中：

• dv表示绝对湿度，单位是g/m^3，克/立方米。
• t表示当前环境温度；
• RH表示相对湿度，值为百分比形式（%）；
• m = 17.62
• Tn = 243.12 摄氏度
• A = 6.112 hPa