移动传感器

Android 平台提供了多种传感器,可让您监控设备的运动。

传感器的可能架构因传感器类型而异:

  • 重力、线性加速度、旋转矢量、大幅度运动、计步器和步测器传感器要么基于硬件,要么基于软件。
  • 加速度计和陀螺仪传感器始终基于硬件。

大多数 Android 设备都配有加速度计,而现在许多设备都带有陀螺仪。基于软件的传感器的可用性更具可变性,因为它们通常依赖一个或多个硬件传感器来获取其数据。这些基于软件的传感器可以从加速度计和磁力计或陀螺仪获取数据,具体取决于设备。

移动传感器对于监控设备移动(例如倾斜、摇晃、旋转或摆动)非常有用。该移动通常反映的用户直接输入(例如,用户在游戏中转向汽车,或在游戏中控制球),但也可以反映设备所在的物理环境(例如,在开车时随着您移动)。在第一种情况下,您监控相对于设备参照系或应用的参照系的运动;在第二种情况下,您监控相对于世界参照系的运动。运动传感器本身通常并不用于监控设备位置,但它们可以与其他传感器(例如地磁场传感器)一起使用,以确定设备相对于世界参照系的位置(如需了解详情,请参阅位置传感器)。

所有移动传感器都会为每个 SensorEvent 返回传感器值的多维数组。例如,在单个传感器事件期间,加速度计会返回三个坐标轴的加速度数据,而陀螺仪会返回三个坐标轴的旋转速率数据。这些数据值以及其他 SensorEvent 参数会在一个 float 数组 (values) 中返回。表 1 总结了在 Android 平台上可用的运动传感器。

表 1. Android 平台支持的移动传感器。

传感器 传感器事件数据 说明 度量单位
TYPE_ACCELEROMETER SensorEvent.values[0] 沿 x 轴的加速力(包括重力)。 米/秒2
SensorEvent.values[1] 沿 y 轴的加速力(包括重力)。
SensorEvent.values[2] 沿 z 轴的加速力(包括重力)。
TYPE_ACCELEROMETER_UNCALIBRATED SensorEvent.values[0] 沿 X 轴测量的加速度,没有任何偏差补偿。 米/秒2
SensorEvent.values[1] 沿 Y 轴测量的加速度,没有任何偏差补偿。
SensorEvent.values[2] 沿 Z 轴测量的加速度,没有任何偏差补偿。
SensorEvent.values[3] 沿 X 轴测量的加速度,并带有估算的偏差补偿。
SensorEvent.values[4] 沿 Y 轴测量的加速度,并带有估算的偏差补偿。
SensorEvent.values[5] 沿 Z 轴测量的加速度,并带有估算的偏差补偿。
TYPE_GRAVITY SensorEvent.values[0] 沿 x 轴的重力。 米/秒2
SensorEvent.values[1] 沿 y 轴的重力。
SensorEvent.values[2] 沿 z 轴的重力。
TYPE_GYROSCOPE SensorEvent.values[0] 绕 x 轴的旋转速率。 弧度/秒
SensorEvent.values[1] 绕 y 轴的旋转速率。
SensorEvent.values[2] 绕 z 轴的旋转速率。
TYPE_GYROSCOPE_UNCALIBRATED SensorEvent.values[0] 绕 x 轴的旋转速率(无漂移补偿)。 弧度/秒
SensorEvent.values[1] 绕 y 轴的旋转速率(无漂移补偿)。
SensorEvent.values[2] 绕 z 轴的旋转速率(无漂移补偿)。
SensorEvent.values[3] 绕 x 轴的估算漂移。
SensorEvent.values[4] 绕 y 轴的估算漂移。
SensorEvent.values[5] 绕 z 轴的估算漂移。
TYPE_LINEAR_ACCELERATION SensorEvent.values[0] 沿 x 轴的加速力(不包括重力)。 米/秒2
SensorEvent.values[1] 沿 y 轴的加速力(不包括重力)。
SensorEvent.values[2] 沿 z 轴的加速力(不包括重力)。
TYPE_ROTATION_VECTOR SensorEvent.values[0] 沿 x 轴的旋转矢量分量 (x * sin(θ/2))。 无单位
SensorEvent.values[1] 沿 y 轴的旋转矢量分量 (y * sin(θ/2))。
SensorEvent.values[2] 沿 z 轴的旋转矢量分量 (z * sin(θ/2))。
SensorEvent.values[3] 旋转矢量的标量分量 ((cos(查看所有)/2)。1
TYPE_SIGNIFICANT_MOTION 不适用 不适用 不适用
TYPE_STEP_COUNTER SensorEvent.values[0] 激活传感器后,自上次重新启动以来用户行走的步数。 步骤
TYPE_STEP_DETECTOR 不适用 不适用 不适用

1 标量组成部分是可选值。

旋转矢量传感器和重力传感器是移动侦测和监控中最常用的传感器。旋转矢量传感器特别通用,可用于各种与运动相关的任务,如检测手势、监控角度变化和监控相对方向变化。例如,如果您要开发游戏、增强现实应用、二维或 3 维罗盘或者相机防抖应用,那么旋转矢量传感器就是理想之选。在大多数情况下,使用这些传感器比使用加速度计和地磁场传感器或方向传感器是更好的选择。

Android 开源项目传感器

Android 开源项目 (AOSP) 提供了三种基于软件的移动传感器:重力传感器、线性加速度传感器和旋转矢量传感器。这些传感器在 Android 4.0 中进行了更新,现在使用设备的陀螺仪(除其他传感器之外)来提高稳定性和性能。如果您想试用这些传感器,可以使用 getVendor() 方法和 getVersion() 方法(供应商为 Google LLC;版本号为 3)来识别它们。您必须按供应商和版本号识别这些传感器,因为 Android 系统将这三个传感器视为辅助传感器。例如,如果设备制造商提供自己的重力传感器,则 AOSP 重力传感器会显示为辅助重力传感器。所有三个传感器都依赖于陀螺仪:如果设备没有陀螺仪,则这些传感器不会显示,并且无法使用。

使用重力传感器

重力传感器提供了一个表示重力方向和大小的三维矢量。通常,此传感器用于确定设备在空间中的相对方向。以下代码展示了如何获取默认重力传感器的实例:

Kotlin

val sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager
val sensor: Sensor? = sensorManager.getDefaultSensor(Sensor.TYPE_GRAVITY)

Java

private SensorManager sensorManager;
private Sensor sensor;
...
sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
sensor = sensorManager.getDefaultSensor(Sensor.TYPE_GRAVITY);

单位与加速度传感器使用的单位 (m/s2) 相同,坐标系与加速度传感器使用的坐标系相同。

注意:当设备处于静止状态时,重力传感器的输出应与加速度计的输出相同。

使用线性加速度计

线性加速度传感器为您提供了一个三维矢量,表示沿每个设备轴的加速度(不包括重力)。您可以使用此值执行手势检测。该值还可用作使用航位推算的惯性导航系统的输入值。以下代码展示了如何获取默认线性加速度传感器的实例:

Kotlin

val sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager
val sensor: Sensor? = sensorManager.getDefaultSensor(Sensor.TYPE_LINEAR_ACCELERATION)

Java

private SensorManager sensorManager;
private Sensor sensor;
...
sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
sensor = sensorManager.getDefaultSensor(Sensor.TYPE_LINEAR_ACCELERATION);

从概念上讲,该传感器根据以下关系为您提供加速度数据:

linear acceleration = acceleration - acceleration due to gravity

通常,当您想要获取加速度数据而不受重力影响时,就可以使用该传感器。例如,您可以使用此传感器查看汽车行驶的速度。线性加速度传感器始终有一个偏移,您需要将其移除。最简单的方法是在应用中构建一个校准步骤。在校准期间,您可以要求用户将设备放在桌子上,然后读取所有三个轴的偏移量。然后,您可以从加速度传感器的直接读数中减去该偏移量,从而得出实际的线性加速度。

传感器坐标与加速度传感器使用的坐标系相同,计量单位 (m/s2) 也相同。

使用旋转矢量传感器

旋转矢量以角度和轴的组合的形式表示设备的方向,其中设备已围绕轴(x、y 或 z)旋转了一个 ↑ 角度。以下代码展示了如何获取默认旋转矢量传感器的实例:

Kotlin

val sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager
val sensor: Sensor? = sensorManager.getDefaultSensor(Sensor.TYPE_ROTATION_VECTOR)

Java

private SensorManager sensorManager;
private Sensor sensor;
...
sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
sensor = sensorManager.getDefaultSensor(Sensor.TYPE_ROTATION_VECTOR);

旋转矢量的三个元素表示如下:

x*sin(θ/2)、y*sin(θ/2)、z*sin(θ/2)

其中,旋转矢量的大小等于 sin(不正确/2),且旋转矢量的方向等于旋转轴的方向。

图 1. 旋转矢量传感器使用的坐标系。

旋转向量的三个元素等于单位四元数的最后三个分量 (cos(将显示/2)、x*sin(不正确/2)、y*sin(不正确) 或 z*sin(皮下/2)。旋转矢量的元素没有单位。x、y 和 z 轴的定义方式与加速度传感器相同。参考坐标系被定义为直接正交基础(参见图 1)。该坐标系具有以下特性:

  • X 定义为矢量积 Y x Z。它在设备当前位置与地面相切,并大致指向东。
  • Y 在设备当前位置与地面相切,并指向地磁北极。
  • Z 指向天空并与地平面垂直。

如需查看示例应用,了解如何使用旋转矢量传感器,请参阅 RotationVectorDemo.java

使用有效运动传感器

每次检测到有效动作时,有效运动传感器都会触发事件,然后自行停用。大幅度动作是指可能导致用户位置发生变化的动作;例如,步行、骑自行车或坐在行驶的汽车中。以下代码展示了如何获取默认有效移动传感器的实例以及如何注册事件监听器:

Kotlin

val sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager
val mSensor: Sensor? = sensorManager.getDefaultSensor(Sensor.TYPE_SIGNIFICANT_MOTION)
val triggerEventListener = object : TriggerEventListener() {
    override fun onTrigger(event: TriggerEvent?) {
        // Do work
    }
}
mSensor?.also { sensor ->
    sensorManager.requestTriggerSensor(triggerEventListener, sensor)
}

Java

private SensorManager sensorManager;
private Sensor sensor;
private TriggerEventListener triggerEventListener;
...
sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
sensor = sensorManager.getDefaultSensor(Sensor.TYPE_SIGNIFICANT_MOTION);

triggerEventListener = new TriggerEventListener() {
    @Override
    public void onTrigger(TriggerEvent event) {
        // Do work
    }
};

sensorManager.requestTriggerSensor(triggerEventListener, mSensor);

如需了解详情,请参阅 TriggerEventListener

使用计步器传感器

计步器传感器提供自上次重新启动以来且激活传感器后用户行走的步数。与步测器传感器相比,计步器的延迟时间更长(最长 10 秒),但精确度更高。

注意 :您必须声明 ACTIVITY_RECOGNITION 权限,应用才能在搭载 Android 10(API 级别 29)或更高版本的设备上使用此传感器。

以下代码展示了如何获取默认计步器传感器的实例:

Kotlin

val sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager
val sensor: Sensor? = sensorManager.getDefaultSensor(Sensor.TYPE_STEP_COUNTER)

Java

private SensorManager sensorManager;
private Sensor sensor;
...
sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
sensor = sensorManager.getDefaultSensor(Sensor.TYPE_STEP_COUNTER);

为了节省运行应用的设备的电量,您应使用 JobScheduler 类以特定的时间间隔从计步器传感器检索当前值。虽然不同类型的应用需要不同的传感器读取间隔,但除非应用需要来自传感器的实时数据,否则您应尽可能延长此间隔。

使用步测器传感器

每次用户迈步时,步测器传感器都会触发事件。延迟时间预计低于 2 秒。

注意 :您必须声明 ACTIVITY_RECOGNITION 权限,应用才能在搭载 Android 10(API 级别 29)或更高版本的设备上使用此传感器。

以下代码展示如何获取默认步测器传感器的实例:

Kotlin

val sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager
val sensor: Sensor? = sensorManager.getDefaultSensor(Sensor.TYPE_STEP_DETECTOR)

Java

private SensorManager sensorManager;
private Sensor sensor;
...
sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
sensor = sensorManager.getDefaultSensor(Sensor.TYPE_STEP_DETECTOR);

使用原始数据

以下传感器可为您的应用提供有关施加到设备的线性力和旋转力的原始数据。为了有效地使用这些传感器的值,您需要滤除环境中的因素,例如重力。您可能还需要对值趋势应用平滑算法,以减少噪声。

使用加速度计

加速度传感器用于测量施加到设备的加速度,包括重力。以下代码展示如何获取默认加速传感器的实例:

Kotlin

val sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager
val sensor: Sensor? = sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER)

Java

private SensorManager sensorManager;
private Sensor sensor;
  ...
sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
sensor = sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);

注意 :如果您的应用以 Android 12(API 级别 31)或更高版本为目标平台,此传感器受到速率限制

从概念上讲,加速度传感器通过测量施加给传感器本身的力 (Fs) 的方式使用以下关系确定施加到设备的加速度 (Ad):

A_D=-(1/mass)∑F_S

不过,重力始终会根据以下关系影响测量的加速度:

A_D=-g-(1/mass)∑F_S

因此,当设备放在桌子上(没有加速)时,加速度计的读数为 g = 9.81 m/s2。同样,当设备处于自由下落状态,并因此以 9.81 m/s2 的速度向地面快速加速时,其加速度计的读数为 g = 0 m/s2 量级。因此,为了测量设备的实际加速度,必须从加速度计数据中移除重力的作用。这可以通过应用高通滤波器来实现。相反,可以使用低通滤波器来隔离重力。以下示例展示了如何执行此操作:

Kotlin

override fun onSensorChanged(event: SensorEvent) {
    // 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.

    val alpha: Float = 0.8f

    // 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]
}

Java

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];
}

注意:您可以使用许多不同的技术来过滤传感器数据。上面的代码示例使用简单的滤波器常量 (alpha) 来创建低通滤波器。此过滤器常数派生自时间常数 (t),大致表示过滤器添加到传感器事件的延迟时间以及传感器的事件传递率 (dt)。此代码示例使用 0.8 的 Alpha 值进行演示。如果您使用此过滤方法,则可能需要选择其他 Alpha 值。

加速度计使用标准的传感器坐标系。实际上,这意味着当设备以其自然屏幕方向平放在桌子上时,以下条件适用:

  • 如果将设备推向左侧(因此设备会向右移动),则 x 加速度值为正。
  • 如果您将设备推到底部(使其远离您),则 y 加速度值为正。
  • 如果您以 A m/s2 的加速度将设备推向天空,z 加速度值等于 A + 9.81,等于设备的加速度 (+A m/s2) 减去重力 (-9.81 m/s2)。
  • 静止设备的加速度值为 +9.81,相当于设备的加速度(0 m/s2 减去重力,即 -9.81 m/s2)。

一般来说,在监测设备运动时,加速度计是一个很好的传感器。几乎所有搭载 Android 的手机和平板电脑都配有加速度计,其功耗比其他运动传感器低约 10 倍。其中一个缺点是,您可能必须实现低通和高通滤波器,以消除重力并减少噪声。

使用陀螺仪

陀螺仪测量围绕设备的 x、y 和 z 轴的旋转速率(以 rad/s 为单位)。以下代码展示如何获取默认陀螺仪的实例:

Kotlin

val sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager
val sensor: Sensor? = sensorManager.getDefaultSensor(Sensor.TYPE_GYROSCOPE)

Java

private SensorManager sensorManager;
private Sensor sensor;
...
sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
sensor = sensorManager.getDefaultSensor(Sensor.TYPE_GYROSCOPE);

注意 :如果您的应用以 Android 12(API 级别 31)或更高版本为目标平台,此传感器受到速率限制

传感器的坐标系与加速度传感器使用的坐标系相同。逆时针方向旋转为正;也就是说,如果观察者从位于原点的设备 x、y 或 z 轴上的某个正位置看向,则如果设备看似逆时针旋转,则观察者将报告正旋转。这是正向旋转的标准数学定义,与方向传感器使用的翻滚定义不同。

通常,陀螺仪的输出会随时间进行集成,以计算描述角度随时间步长变化的旋转。例如:

Kotlin

// Create a constant to convert nanoseconds to seconds.
private val NS2S = 1.0f / 1000000000.0f
private val deltaRotationVector = FloatArray(4) { 0f }
private var timestamp: Float = 0f

override fun onSensorChanged(event: SensorEvent?) {
    // This timestep's delta rotation to be multiplied by the current rotation
    // after computing it from the gyro sample data.
    if (timestamp != 0f && event != null) {
        val dT = (event.timestamp - timestamp) * NS2S
        // Axis of the rotation sample, not normalized yet.
        var axisX: Float = event.values[0]
        var axisY: Float = event.values[1]
        var axisZ: Float = event.values[2]

        // Calculate the angular speed of the sample
        val omegaMagnitude: Float = 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.
        val thetaOverTwo: Float = omegaMagnitude * dT / 2.0f
        val sinThetaOverTwo: Float = sin(thetaOverTwo)
        val cosThetaOverTwo: Float = cos(thetaOverTwo)
        deltaRotationVector[0] = sinThetaOverTwo * axisX
        deltaRotationVector[1] = sinThetaOverTwo * axisY
        deltaRotationVector[2] = sinThetaOverTwo * axisZ
        deltaRotationVector[3] = cosThetaOverTwo
    }
    timestamp = event?.timestamp?.toFloat() ?: 0f
    val deltaRotationMatrix = FloatArray(9) { 0f }
    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;
}

Java

// 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;
}

标准陀螺仪提供原始旋转数据,无需对噪声和偏移(偏差)进行任何过滤或校正。实际上,陀螺仪的噪声和偏移会引入需要补偿的误差。您通常需要通过监控其他传感器(如重力传感器或加速度计)来确定偏移(偏差)和噪声。

使用未经校准的陀螺仪

未经校准的陀螺仪与陀螺仪类似,不同之处在于旋转速率不会应用陀螺偏移补偿。出厂校准和温度补偿仍应用于旋转速率。未校准的陀螺仪可用于后期处理和融合屏幕方向数据。通常,gyroscope_event.values[0] 将接近 uncalibrated_gyroscope_event.values[0] - uncalibrated_gyroscope_event.values[3]。即,

calibrated_x ~= uncalibrated_x - bias_estimate_x

注意:未校准的传感器提供更多原始结果,并且可能包含一些偏差,但其测量值包含通过校准执行的校正产生的跳跃更少。某些应用可能更倾向于使用这些未校准结果,因为此类结果更顺畅、更可靠。例如,如果应用尝试自行进行传感器融合,则引入校准实际上可能会使结果失真。

除了旋转速率外,未经校准的陀螺仪还会提供围绕每个轴的估算漂移。以下代码展示了如何获取默认未校准陀螺仪的实例:

Kotlin

val sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager
val sensor: Sensor? = sensorManager.getDefaultSensor(Sensor.TYPE_GYROSCOPE_UNCALIBRATED)

Java

private SensorManager sensorManager;
private Sensor sensor;
...
sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
sensor = sensorManager.getDefaultSensor(Sensor.TYPE_GYROSCOPE_UNCALIBRATED);

更多代码示例

BatchStepSensor 示例进一步演示了如何使用本页介绍的 API。

另请阅读