此页面由 Cloud Translation API 翻译。

移动传感器

Android 平台提供了多种传感器，以便您监控相关运动

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

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

大多数 Android 设备都配有加速度计，而现在许多设备都配有陀螺仪。基于软件的传感器的可用性变量，因为它们通常依赖一个或多个硬件传感器来获取其数据，数据。根据设备的不同，这些基于软件的传感器可以推导出其来自加速度计和磁力计或陀螺仪的数据。

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

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

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

传感器	传感器事件数据	说明	度量单位
`TYPE_ACCELEROMETER`	`SensorEvent.values[0]`	沿 x 轴的加速力（包括重力）。	米/秒²
	`SensorEvent.values[1]`	沿 y 轴的加速力（包括重力）。
	`SensorEvent.values[2]`	沿 z 轴的加速力（包括重力）。
`TYPE_ACCELEROMETER_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_GRAVITY`	`SensorEvent.values[0]`	沿 x 轴的重力。	米/秒²
	`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 轴的加速力（不包括重力）。	米/秒²
	`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(them/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

如果您要获取加速度数据，而不受重力。例如，您可以使用此传感器了解汽车的行驶速度。线性模型加速度传感器始终都有一个偏移量，您需要将其移除。最简单的方法是在应用中构建一个校准步骤。在校准期间，您可以让用户放在桌子上，然后读取所有三个轴的偏移量。然后，您可以加速度传感器直接读数的偏移量，以获取实际的线性加速。

传感器坐标 system 与加速度传感器使用的方法相同， (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(环聊二次调用)，旋转矢量的方向为旋转矢量等于旋转轴的方向。

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

旋转矢量的三个元素等于单元的最后三个分量四元数 (cos(Twitter)/2, x*sin(账号的) 取值, y*sin(账号的二元数)， z*sin(账号的可选)。旋转矢量的元素为无单位。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）或这个传感器就是有速率限制。

从概念上讲，加速度传感器确定施加的加速度，通过测量施加到传感器的力来将传感器应用于设备 (Ad) 本身 (F_s) 定义如下关系：

但是，重力始终都会影响测量的加速度，以下关系：

因此，当设备放在桌子上（没有加速）时，加速度计的读数为 g = 9.81 m/s²。同样，当设备进入因此会以 9.81 米/秒²的速度向地面快速加速加速度计的读数为 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 值

加速度计使用标准传感器坐标 system。在实践中，这意味着当设备处于平铺状态时，以下条件适用处于自然方向的桌子上：

如果您向左推动设备（因此向右移动），则 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 轴。以下代码展示如何获取默认陀螺仪的实例：

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

更多代码示例

另请阅读