此页面由 Cloud Translation API 翻译。

移动传感器

Android 平台提供了多种传感器，可用于监控设备的运动。

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

重力、线性加速度、旋转矢量、大幅度动作、计步器和步测器传感器可以是基于硬件的，也可以是基于软件的。
加速度计和陀螺仪传感器始终基于硬件。

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

运动传感器可用于监控设备运动，例如倾斜、摇晃、旋转或挥动。运动通常反映了直接的用户输入（例如，用户在游戏中驾驶汽车或控制球），但也可能反映了设备所处的物理环境（例如，在您驾驶汽车时随您一起移动）。在第一种情况下，您监控的是相对于设备参考帧或应用参考帧的运动；在第二种情况下，您监控的是相对于世界参考帧的运动。运动传感器本身通常不用于监控设备位置，但可以与其他传感器（例如地磁场传感器）搭配使用，以确定设备相对于世界参照系的位置（如需了解详情，请参阅位置传感器）。

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

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

传感器	传感器事件数据	说明	度量单位
`TYPE_ACCELEROMETER`	`SensorEvent.values[0]`	沿 x 轴的加速力（包括重力）。	m/s²
	`SensorEvent.values[1]`	沿 y 轴的加速力（包括重力）。
	`SensorEvent.values[2]`	沿 z 轴的加速力（包括重力）。
`TYPE_ACCELEROMETER_UNCALIBRATED`	`SensorEvent.values[0]`	沿 X 轴测量的加速度，没有任何偏差补偿。	m/s²
	`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 轴的重力。	m/s²
	`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 轴的加速力（不包括重力）。	m/s²
	`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))。¹
`TYPE_SIGNIFICANT_MOTION`	不适用	不适用	不适用
`TYPE_STEP_COUNTER`	`SensorEvent.values[0]`	自传感器激活后上一次重新启动以来用户行走的步数。	步骤
`TYPE_STEP_DETECTOR`	不适用	不适用	不适用

¹ 标量分量是可选值。

旋转矢量传感器和重力传感器是用于运动检测和监控的最常用传感器。旋转矢量传感器用途广泛，可用于执行各种与运动相关的任务，例如检测手势、监控角度变化和监控相对方向变化。例如，如果您要开发游戏、增强现实应用、二维或三维指南针，或者相机稳定应用，那么旋转矢量传感器就是理想之选。在大多数情况下，使用这些传感器比使用加速度计和地磁场传感器或方向传感器更好。

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/s²) 相同，坐标系与加速度传感器使用的坐标系相同。

注意：当设备静止时，重力传感器的输出结果应与加速度计的输出结果相同。

使用线性加速度计

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

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/s²) 也相同。

使用旋转矢量传感器

旋转矢量将设备的屏幕方向表示为角度和轴的组合，其中设备已围绕轴（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);

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

其中，旋转向量的大小等于 sin(θ/2)，旋转向量的方向等于旋转轴的方向。

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

旋转向量的三个元素等于单位四元数 (cos(θ/2), x*sin(θ/2), y*sin(θ/2), 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）或更高版本为目标平台，则此传感器会受到速率限制。

从概念上讲，加速度传感器通过测量施加到传感器本身 (F_s) 的力来确定施加到设备的加速度 (A_d)，二者之间的关系如下：

不过，重力始终会影响所测量的加速度，具体关系如下：

因此，当设备放在桌子上（且未加速）时，加速度计读出的加速度大小为 g = 9.81 m/s²。同样，当设备处于自由落体状态时，会以 9.81 m/s² 的速度快速向地面加速，此时加速度计读出的加速度大小为 g = 0 m/s²。因此，为了测量设备的真实加速度，必须从加速度计数据中移除重力的贡献。这可以通过应用高通滤波器来实现。相反，低通滤波器可用于隔离重力。以下示例展示了如何执行此操作：

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/s² 的加速度向上推动设备，则 z 轴加速度值等于 A + 9.81，相当于设备的加速度 (+A m/s²) 减去重力加速度 (-9.81 m/s²)。
静止的设备将具有 +9.81 的加速度值，相当于设备的加速度（0 m/s²）减去重力加速度（-9.81 m/s²）。

一般来说，如果您要监控设备运动，加速度计是一个不错的选择。几乎所有 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);

移动传感器

Android 开源项目传感器

使用重力传感器

Kotlin

Java

使用线性加速度计

Kotlin

Java

使用旋转矢量传感器

Kotlin

Java

使用有效运动传感器

Kotlin

Java

使用计步器传感器

Kotlin

Java

使用步测器传感器

Kotlin

Java

使用原始数据

使用加速度计

Kotlin

Java

Kotlin

Java

使用陀螺仪

Kotlin

Java

Kotlin

Java

使用未经校准的陀螺仪

Kotlin

Java

更多代码示例

另请阅读