萬盛學電腦網

您现在的位置: 萬盛學電腦網 >> 程式設計 >  >> 網路程式設計 >> Android 開發

Android 感測器程式設計完整指南:類型、架構與最佳實踐

Android 感測器框架概覽

Android 感測器框架提供統一介面存取裝置硬體感測器。核心類別:

  • SensorManager:系統服務,管理感測器清單、註冊/取消監聽器
  • Sensor:單一感測器描述 (類型、廠商、版本、最大範圍、解析度、功耗、最小延遲)
  • SensorEvent:感測器資料事件 (值陣列、時間戳、感測器、精度)
  • SensorEventListener:回調介面 (onSensorChanged、onAccuracyChanged)

感測器類型完整分類

類型常數名稱資料維度單位典型用途是否硬體
TYPE_ACCELEROMETER加速度計3 (x,y,z)m/s²傾斜、震動、計步、遊戲控制硬體
TYPE_GYROSCOPE陀螺儀3 (x,y,z)rad/s旋轉角速度、姿態融合、VR/AR硬體
TYPE_MAGNETIC_FIELD磁力計/指南針3 (x,y,z)μT指南針、金屬偵測、姿態融合硬體
TYPE_ORIENTATION方向 (已棄用)3 (azimuth,pitch,roll)度⚠ 使用 SensorManager.getOrientation() 替代軟體融合
TYPE_LIGHT環境光線1lx (lux)螢幕亮度自動調整硬體
TYPE_PROXIMITY接近感測器1cm通話關螢幕、口袋模式硬體
TYPE_PRESSURE氣壓計1hPa (mbar)海拔高度、天氣預測、樓層偵測硬體
TYPE_TEMPERATURE環境溫度 (API 14+)1°C環境溫度監測 (非 CPU 溫度)硬體
TYPE_RELATIVE_HUMIDITY相對濕度1%環境濕度監測硬體
TYPE_GRAVITY重力向量3m/s²姿態判斷、傾斜修正軟體融合
TYPE_LINEAR_ACCELERATION線性加速度3m/s²移動檢測、手勢識別 (扣除重力)軟體融合
TYPE_ROTATION_VECTOR旋轉向量3/4/5無單位 (四元數)高精度姿態、AR/VR、地平線軟體融合
TYPE_GAME_ROTATION_VECTOR遊戲旋轉向量3/4無單位遊戲專用,無磁力計漂移軟體融合
TYPE_GEOMAGNETIC_ROTATION_VECTOR地磁旋轉向量3/4無單位低功耗姿態 (無陀螺儀)軟體融合
TYPE_STEP_COUNTER計步器1步數健康追蹤、計步 (硬體加速)硬體
TYPE_STEP_DETECTOR偵測步行1觸發事件即時步行偵測硬體
TYPE_SIGNIFICANT_MOTION顯著運動1觸發事件喚醒裝置、模式切換硬體
TYPE_ACCELEROMETER_UNCALIBRATED未校準加速度6 (x,y,z, bias_x,bias_y,bias_z)m/s²校準、研究用硬體
TYPE_GYROSCOPE_UNCALIBRATED未校準陀螺儀6rad/s校準、研究用硬體
TYPE_MAGNETIC_FIELD_UNCALIBRATED未校準磁力6μT校準、研究用硬體
TYPE_HEART_RATE心率1bpm穿戴裝置心率監測硬體
TYPE_POSE_6DOF6DOF 姿態7 (位置+旋轉)m, 四元數AR/VR 追蹤 (API 29+)軟體融合

感測器可用性檢查與最佳實踐

public class SensorManagerHelper {
    private final SensorManager sensorManager;
    private final Map availableSensors = new HashMap<>();

    public SensorManagerHelper(Context context) {
        sensorManager = (SensorManager) context.getSystemService(Context.SENSOR_SERVICE);
        // 快取所有可用感測器
        List sensors = sensorManager.getSensorList(Sensor.TYPE_ALL);
        for (Sensor sensor : sensors) {
            availableSensors.put(sensor.getType(), sensor);
        }
    }

    /** 檢查感測器是否存在 */
    public boolean hasSensor(int type) {
        return availableSensors.containsKey(type);
    }

    /** 取得感測器資訊字串 */
    public String getSensorInfo(int type) {
        Sensor sensor = availableSensors.get(type);
        if (sensor == null) return "Not available";
        return String.format(Locale.getDefault(),
            "Name: %s\nVendor: %s\nVersion: %d\nMax Range: %.2f\nResolution: %.4f\nPower: %.2f mA\nMin Delay: %d μs",
            sensor.getName(), sensor.getVendor(), sensor.getVersion(),
            sensor.getMaximumRange(), sensor.getResolution(),
            sensor.getPower(), sensor.getMinDelay());
    }

    /** 註冊監聽器 (自動處理生命週期) */
    public boolean registerListener(SensorEventListener listener, int sensorType, int rateUs) {
        Sensor sensor = availableSensors.get(sensorType);
        if (sensor == null) return false;
        return sensorManager.registerListener(listener, sensor, rateUs);
    }

    /** 註冊監聽器 (使用 SensorDelay 常數) */
    public boolean registerListener(SensorEventListener listener, int sensorType, int delay) {
        Sensor sensor = availableSensors.get(sensorType);
        if (sensor == null) return false;
        return sensorManager.registerListener(listener, sensor, delay);
    }

    public void unregisterListener(SensorEventListener listener) {
        sensorManager.unregisterListener(listener);
    }

    /** 建議的採樣率常數對照 */
    public static class SensorDelay {
        public static final int FASTEST = SensorManager.SENSOR_DELAY_FASTEST;     // ~0-1ms (盡可能快)
        public static final int GAME = SensorManager.SENSOR_DELAY_GAME;           // ~20ms (50Hz)
        public static final int UI = SensorManager.SENSOR_DELAY_UI;               // ~60ms (16Hz)
        public static final int NORMAL = SensorManager.SENSOR_DELAY_NORMAL;       // ~200ms (5Hz)
        
        // 自訂微秒延遲 (API 16+)
        public static int customDelayUs(int microseconds) {
            return microseconds;
        }
    }
}

完整感測器監聽實作範例

public class SensorActivity extends AppCompatActivity implements SensorEventListener {
    private static final String TAG = "SensorActivity";
    
    private SensorManagerHelper sensorHelper;
    private TextView accelText, gyroText, magText, lightText, proxText;
    private SensorEventListener accelListener, gyroListener;
    
    // 低通濾波器參數 (用於分離重力/線性加速度)
    private static final float ALPHA = 0.8f;
    private float[] gravity = new float[3];
    private float[] linearAccel = new float[3];

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_sensor);
        
        accelText = findViewById(R.id.accel_data);
        gyroText = findViewById(R.id.gyro_data);
        magText = findViewById(R.id.mag_data);
        lightText = findViewById(R.id.light_data);
        proxText = findViewById(R.id.prox_data);
        
        sensorHelper = new SensorManagerHelper(this);
        
        // 顯示可用感測器清單
        Log.d(TAG, "Available sensors: " + sensorHelper.availableSensors.keySet());
    }

    @Override
    protected void onResume() {
        super.onResume();
        // 註冊感測器 (UI 速率 ~60ms)
        if (sensorHelper.hasSensor(Sensor.TYPE_ACCELEROMETER)) {
            sensorHelper.registerListener(this, Sensor.TYPE_ACCELEROMETER, SensorManager.SENSOR_DELAY_UI);
        }
        if (sensorHelper.hasSensor(Sensor.TYPE_GYROSCOPE)) {
            sensorHelper.registerListener(this, Sensor.TYPE_GYROSCOPE, SensorManager.SENSOR_DELAY_UI);
        }
        if (sensorHelper.hasSensor(Sensor.TYPE_MAGNETIC_FIELD)) {
            sensorHelper.registerListener(this, Sensor.TYPE_MAGNETIC_FIELD, SensorManager.SENSOR_DELAY_UI);
        }
        if (sensorHelper.hasSensor(Sensor.TYPE_LIGHT)) {
            sensorHelper.registerListener(this, Sensor.TYPE_LIGHT, SensorManager.SENSOR_DELAY_NORMAL);
        }
        if (sensorHelper.hasSensor(Sensor.TYPE_PROXIMITY)) {
            sensorHelper.registerListener(this, Sensor.TYPE_PROXIMITY, SensorManager.SENSOR_DELAY_NORMAL);
        }
    }

    @Override
    protected void onPause() {
        super.onPause();
        // 必須在 onPause 取消註冊,否則洩漏電量與資源
        sensorHelper.unregisterListener(this);
    }

    @Override
    public void onSensorChanged(SensorEvent event) {
        // 注意:此回調在感測器執行緒,不可直接操作 UI
        // 使用 runOnUiThread 或 Handler 更新 UI
        
        switch (event.sensor.getType()) {
            case Sensor.TYPE_ACCELEROMETER:
                // 低通濾波分離重力與線性加速度
                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];
                
                linearAccel[0] = event.values[0] - gravity[0];
                linearAccel[1] = event.values[1] - gravity[1];
                linearAccel[2] = event.values[2] - gravity[2];
                
                runOnUiThread(() -> accelText.setText(String.format(Locale.getDefault(),
                    "加速度: X=%.2f Y=%.2f Z=%.2f\n線性: X=%.2f Y=%.2f Z=%.2f\n重力: X=%.2f Y=%.2f Z=%.2f",
                    event.values[0], event.values[1], event.values[2],
                    linearAccel[0], linearAccel[1], linearAccel[2],
                    gravity[0], gravity[1], gravity[2])));
                break;
                
            case Sensor.TYPE_GYROSCOPE:
                runOnUiThread(() -> gyroText.setText(String.format(Locale.getDefault(),
                    "陀螺儀: X=%.4f Y=%.4f Z=%.4f rad/s", 
                    event.values[0], event.values[1], event.values[2])));
                break;
                
            case Sensor.TYPE_MAGNETIC_FIELD:
                runOnUiThread(() -> magText.setText(String.format(Locale.getDefault(),
                    "磁力: X=%.2f Y=%.2f Z=%.2f μT", 
                    event.values[0], event.values[1], event.values[2])));
                break;
                
            case Sensor.TYPE_LIGHT:
                runOnUiThread(() -> lightText.setText(String.format(Locale.getDefault(),
                    "環境光: %.1f lux", event.values[0])));
                break;
                
            case Sensor.TYPE_PROXIMITY:
                // 接近感測器通常只回傳 0 (近) 或最大值 (遠)
                float distance = event.values[0];
                float maxRange = event.sensor.getMaximumRange();
                runOnUiThread(() -> proxText.setText(String.format(Locale.getDefault(),
                    "接近: %.1f cm (最大: %.1f cm) - %s", 
                    distance, maxRange, distance < maxRange ? "近" : "遠")));
                break;
        }
    }

    @Override
    public void onAccuracyChanged(Sensor sensor, int accuracy) {
        String[] accuracyLabels = {"不可靠", "低精度", "中精度", "高精度"};
        Log.d(TAG, sensor.getName() + " accuracy: " + accuracyLabels[accuracy]);
    }
}

姿態融合:取得裝置方向 (方位角/俯仰/翻滾)

使用 TYPE_ROTATION_VECTOR + SensorManager.getOrientation() 是現代標準做法:

public class OrientationHelper implements SensorEventListener {
    private final float[] rotationMatrix = new float[9];
    private final float[] orientation = new float[3]; // azimuth, pitch, roll
    private final float[] rotationVector = new float[5];
    private OnOrientationChangeListener listener;

    public interface OnOrientationChangeListener {
        void onOrientationChanged(float azimuth, float pitch, float roll);
    }

    public void setListener(OnOrientationChangeListener listener) {
        this.listener = listener;
    }

    @Override
    public void onSensorChanged(SensorEvent event) {
        if (event.sensor.getType() == Sensor.TYPE_ROTATION_VECTOR) {
            System.arraycopy(event.values, 0, rotationVector, 0, event.values.length);
            SensorManager.getRotationMatrixFromVector(rotationMatrix, rotationVector);
            SensorManager.getOrientation(rotationMatrix, orientation);
            
            // 轉換為度數
            float azimuth = (float) Math.toDegrees(orientation[0]);  // 方位角 (Z軸旋轉)
            float pitch = (float) Math.toDegrees(orientation[1]);    // 俯仰角 (X軸旋轉)
            float roll = (float) Math.toDegrees(orientation[2]);     // 翻滾角 (Y軸旋轉)
            
            // 正規化方位角到 0-360
            if (azimuth < 0) azimuth += 360;
            
            if (listener != null) {
                listener.onOrientationChanged(azimuth, pitch, roll);
            }
        }
    }

    @Override
    public void onAccuracyChanged(Sensor sensor, int accuracy) {}
}

計步器與顯著運動偵測 (硬體加速)

public class StepCounterManager {
    private final SensorManager sensorManager;
    private SensorEventListener stepListener;
    private long lastStepCount = -1;

    public StepCounterManager(Context context) {
        sensorManager = (SensorManager) context.getSystemService(Context.SENSOR_SERVICE);
    }

    public void startCounting(OnStepListener listener) {
        Sensor stepCounter = sensorManager.getDefaultSensor(Sensor.TYPE_STEP_COUNTER);
        Sensor stepDetector = sensorManager.getDefaultSensor(Sensor.TYPE_STEP_DETECTOR);
        
        if (stepCounter == null) {
            Log.w("StepCounter", "Step counter not available");
            return;
        }

        stepListener = new SensorEventListener() {
            @Override
            public void onSensorChanged(SensorEvent event) {
                if (event.sensor.getType() == Sensor.TYPE_STEP_COUNTER) {
                    long currentSteps = (long) event.values[0];
                    if (lastStepCount >= 0) {
                        long delta = currentSteps - lastStepCount;
                        if (delta > 0 && listener != null) {
                            listener.onStepsChanged(currentSteps, delta);
                        }
                    }
                    lastStepCount = currentSteps;
                } else if (event.sensor.getType() == Sensor.TYPE_STEP_DETECTOR) {
                    if (listener != null) {
                        listener.onStepDetected(System.currentTimeMillis());
                    }
                }
            }
            @Override
            public void onAccuracyChanged(Sensor sensor, int accuracy) {}
        };

        // 步數計數器:正常速率即可 (硬體計數)
        sensorManager.registerListener(stepListener, stepCounter, SensorManager.SENSOR_DELAY_NORMAL);
        // 步行偵測器:即時事件
        if (stepDetector != null) {
            sensorManager.registerListener(stepListener, stepDetector, SensorManager.SENSOR_DELAY_FASTEST);
        }
    }

    public void stopCounting() {
        if (stepListener != null) {
            sensorManager.unregisterListener(stepListener);
            stepListener = null;
        }
    }

    public interface OnStepListener {
        void onStepsChanged(long totalSteps, long deltaSteps);
        void onStepDetected(long timestamp);
    }
}

電池優化與效能建議

  1. onPause 確實取消註冊:感測器持續運作會大量消耗電量
  2. 選擇適當採樣率:UI 用 NORMAL/UI,遊戲用 GAME/FASTEST,背景監測用 NORMAL
  3. 使用硬體融合感測器:優先用 TYPE_GRAVITY、TYPE_LINEAR_ACCELERATION、TYPE_ROTATION_VECTOR,而非自行融合原始資料
  4. 批次處理 (Batch/HwFifo):API 19+ SensorManager.registerListener(listener, sensor, rate, maxReportLatencyUs) 讓感測器批次回報,減少喚醒 CPU
  5. 避免在 onSensorChanged 執行複雜運算:僅複製資料,複雜計算移至背景執行緒

批次模式範例 (API 19+)

// 註冊批次模式:最長 5 秒回報一次 (5,000,000 μs)
sensorManager.registerListener(
    listener, 
    accelerometer, 
    SensorManager.SENSOR_DELAY_NORMAL, 
    5_000_000  // maxReportLatencyUs
);

// 監聽器中會收到 SensorAdditionalInfo (API 34+) 或連續事件
// 此模式下 onSensorChanged 可能一次收到多個事件 (FIFO 緩衝區)

總結

Android 感測器框架提供豐富的硬體與融合感測器。核心原則:生命週期正確註冊/取消、選擇適當採樣率、優先使用融合感測器、善用批次模式省電。現代應用結合 SensorManager、ActivityRecognition API、Health Services (Wear OS) 可建構完整的情境感知體驗。

copyright © 萬盛學電腦網 all rights reserved