本頁面由 Cloud Translation API 翻譯而成。

動作感應器

Android 平台提供多種感應器，可讓您監控裝置的動作。

感應器的可能架構會因感應器類型而異：

重力、線性加速度、旋轉向量、重大動作、步數計數器和步數偵測器感應器都是硬體或軟體感應器。
加速計和陀螺儀感應器一律是硬體。

大多數 Android 裝置都配備加速計，現在許多裝置也包含陀螺儀。軟體感應器的供應情形較為多變，因為它們通常會依賴一或多個硬體感應器來擷取資料。視裝置而定，這些以軟體為基礎的感應器可以從加速計和磁力計，或從陀螺儀擷取資料。

動作感應器可用於監控裝置的動作，例如傾斜、搖動、旋轉或擺動。移動通常是直接反映使用者輸入內容 (例如使用者在遊戲中操控汽車或控制球)，但也可能反映裝置所在的實體環境 (例如在您開車時移動)。在第一種情況下，您監控的是相對於裝置參考架構或應用程式參考架構的動作；在第二種情況下，您監控的是相對於世界參考架構的動作。一般來說，動作感應器不會用於監控裝置位置，但可搭配地磁場感應器等其他感應器，判斷裝置相對於世界參考架構的位置 (詳情請參閱「位置感應器」)。

所有動作感應器都會針對每個 SensorEvent 傳回感應器值的多維陣列。舉例來說，在單一感應器事件期間，加速計會傳回三個座標軸的加速度資料，而陀螺儀會傳回三個座標軸的旋轉資料速率。這些資料值會與其他 SensorEvent 參數一併傳回至 float 陣列 (values)。表 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(θ/2)).¹)。
`TYPE_SIGNIFICANT_MOTION`	無	不適用	無
`TYPE_STEP_COUNTER`	`SensorEvent.values[0]`	自上次重新啟動以來，使用者在感應器啟用期間走動的步數。	操作步驟
`TYPE_STEP_DETECTOR`	無	不適用	無

¹ 純量元件為選用值。

旋轉向量感應器和重力感應器是用於偵測和監控動作最常用的感應器。旋轉向量感應器特別多用途，可用於各種與動作相關的任務，例如偵測手勢、監控角度變化，以及監控相對方向變化。舉例來說，如果您正在開發遊戲、擴增實境應用程式、2D 或 3D 指南針，或是相機穩定器應用程式，旋轉向量感應器就是理想的選擇。在大多數情況下，使用這些感應器比使用加速計和地磁場感應器或方向感應器更適合。

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 倍。其中一個缺點是，您可能必須實作低通和高通濾波器，才能消除重力力道並減少雜訊。

使用陀螺儀

陀螺儀會以 rad/s 為單位，測量裝置 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。

另請參閱

關於感應器

位置感應器