Android 平台提供了多种传感器,以便您监控相关运动 设备的实际情况
传感器的可能的架构因传感器类型而异:
- 重力、线性加速度、旋转矢量、大幅度动作、步进 计数器和步测器传感器基于硬件, 基于软件
- 加速度计和陀螺仪传感器始终基于硬件。
大多数 Android 设备都配有加速度计,而现在许多设备都配有 陀螺仪。基于软件的传感器的可用性 变量,因为它们通常依赖一个或多个硬件传感器来获取其数据, 数据。根据设备的不同,这些基于软件的传感器可以推导出其 来自加速度计和磁力计或陀螺仪的数据。
移动传感器对于监控设备的移动情况(例如倾斜、摇晃、旋转或 挥杆。这种移动通常反映用户的直接输入内容(例如,用户操控 或用户在游戏中控制球),但这也可以反映 设备所在的物理环境(例如,在驾车时随您一起移动) 您的车上)。在第一种情况下,您要监控相对于设备参照系的运动 或应用的参照系;在第二种情况中,您需要监控 世界的参照系移动传感器本身通常不用于监控 但它们可以与其他传感器(例如地磁场传感器)一起使用, 确定设备相对于世界参照系的位置(如需了解详情,请参阅位置传感器) 信息)。
所有移动传感器都会为每个 SensorEvent
返回传感器值的多维数组。例如,在单个传感器事件期间,加速度计会返回
三个坐标轴的加速度数据,陀螺仪返回旋转速率
三个坐标轴的数据。这些数据值在 float
数组中返回
(values
)以及其他SensorEvent
参数。表 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(them/2))。1 | ||
TYPE_SIGNIFICANT_MOTION |
不适用 | 不适用 | 不适用 |
TYPE_STEP_COUNTER |
SensorEvent.values[0] |
传感器自上次重启以来用户行走的步数 已启用。 | 步骤 |
TYPE_STEP_DETECTOR |
不适用 | 不适用 | 不适用 |
1 标量部分是可选值。
旋转矢量传感器和重力传感器是最常用的运动传感器 检测和监控。旋转矢量传感器用途特别多样,可用于 各种与运动相关的任务,如检测手势、监控角度变化以及 监控相对屏幕方向变化。例如,如果您 正在开发游戏、增强现实应用、二维或三维罗盘, 或相机防抖应用。在大多数情况下,使用这些传感器比 加速度计和地磁场传感器或方向传感器。
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
如果您要获取加速度数据,而不受 重力。例如,您可以使用此传感器了解汽车的行驶速度。线性模型 加速度传感器始终都有一个偏移量,您需要将其移除。最简单的方法是 在应用中构建一个校准步骤。在校准期间,您可以让用户 放在桌子上,然后读取所有三个轴的偏移量。然后,您可以 加速度传感器直接读数的偏移量,以获取实际的线性 加速。
传感器 坐标 system 与加速度传感器使用的方法相同, (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)](https://developer.android.google.cn/static/images/guide/topics/sensors/rotational_vec.png?authuser=0000&hl=hu)
其中,旋转矢量的大小等于 sin(环聊二次调用),旋转矢量的方向为 旋转矢量等于旋转轴的方向。
![](https://developer.android.google.cn/static/images/axis_globe.png?authuser=0000&hl=hu)
图 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) 本身 (Fs) 定义如下关系:
![A_D=-(1/mass)∑F_S](https://developer.android.google.cn/static/images/guide/topics/sensors/acceleration.png?authuser=0000&hl=hu)
但是,重力始终都会影响测量的加速度, 以下关系:
![A_D=-g-(1/mass)∑F_S](https://developer.android.google.cn/static/images/guide/topics/sensors/acceleration_with_grav.png?authuser=0000&hl=hu)
因此,当设备放在桌子上(没有加速)时, 加速度计的读数为 g = 9.81 m/s2。同样,当设备进入 因此会以 9.81 米/秒2的速度向地面快速加速 加速度计的读数为 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 值
加速度计使用标准传感器 坐标 system。在实践中,这意味着当设备处于平铺状态时,以下条件适用 处于自然方向的桌子上:
- 如果您向左推动设备(因此向右移动),则 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 轴。以下代码展示如何获取默认陀螺仪的实例:
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。