動作感應器

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 純量元件為選用值。

旋轉向量感應器和重力感應器是最常使用的感應器，用於動作偵測和監控。旋轉向量感應器用途廣泛，可用於各種動作相關工作，例如偵測手勢、監控角度變化，以及監控相對方向變化。舉例來說，如果您要開發遊戲、擴增實境應用程式、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/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

您通常會使用這個感應器取得不受重力影響的加速度資料。舉例來說，你可以使用這個感應器查看車輛行駛速度。線性加速度感應器一律會有偏移量，因此您必須移除。最簡單的做法是在應用程式中加入校正步驟。校正期間，您可以要求使用者將裝置放在桌上，然後讀取所有三個軸的偏移量。接著，您可以從加速度感應器的直接讀數中減去該偏移量，取得實際的線性加速度。

感應器座標系統與加速度感應器使用的系統相同，測量單位也是公尺/秒2。

使用旋轉向量感應器

旋轉向量代表裝置的方向，是角度和軸的組合，其中裝置已繞著軸 (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(θ/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) 以上版本，這個感應器會限制速率。

從概念上來說，加速度感應器會透過測量施加在感應器本身的力量 (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。

另請參閱

上一頁
關於感應器
下一頁
位置感應器