Positionssensoren

Die Android-Plattform bietet zwei Sensoren, mit denen Sie die Position eines Geräts ermitteln können: den Sensor für das geomagnetische Feld und den Beschleunigungsmesser. Die Android-Plattform umfasst auch einen Sensor, mit dem Sie feststellen können, wie nahe sich das Gesicht eines Geräts an einem Objekt befindet (sogenannter Näherungssensor). Der Sensor für das geomagnetische Feld und der Näherungssensor sind hardwarebasiert. Die meisten Hersteller von Smartphones und Tablets verwenden einen Sensor für geomagnetische Felder. Ebenso führen Gerätehersteller in der Regel einen Näherungssensor ein, um zu ermitteln, wann das Gerät nah an das Gesicht eines Nutzers gehalten wird, z. B. während eines Telefonanrufs. Zur Bestimmung der Geräteausrichtung können die Messwerte des Beschleunigungsmessers und des Sensors für das geomagnetische Feld des Geräts verwendet werden.

Hinweis:Der Ausrichtungssensor wurde in Android 2.2 (API-Level 8) und der Ausrichtungssensortyp in Android 4.4W (API-Level 20) eingestellt.

Positionssensoren sind nützlich, um die physische Position eines Geräts im Bezugsrahmen der Welt zu ermitteln. Beispielsweise können Sie den Sensor für das geomagnetische Feld zusammen mit dem Beschleunigungsmesser verwenden, um die Position eines Geräts relativ zum magnetischen Nordpol zu bestimmen. Sie können diese Sensoren auch verwenden, um die Ausrichtung eines Geräts im Bezugsrahmen Ihrer App zu ermitteln. Positionssensoren werden in der Regel nicht verwendet, um die Bewegung oder Bewegung von Geräten wie Schüttelarbeiten, Neigung oder Schub zu überwachen (weitere Informationen finden Sie unter Bewegungssensoren).

Der Sensor für das geomagnetische Feld und der Beschleunigungsmesser geben mehrdimensionale Arrays von Sensorwerten für jede SensorEvent zurück. Beispielsweise liefert der Sensor für das geomagnetische Feld bei einem einzelnen Sensorereignis Werte für die geomagnetische Feldstärke für jede der drei Koordinatenachsen. Ebenso misst der Beschleunigungsmesser die Beschleunigung, die auf das Gerät während eines Sensorereignisses angewendet wird. Weitere Informationen zu den von Sensoren verwendeten Koordinatensystemen finden Sie unter Sensorkoordinatensysteme. Der Näherungssensor stellt für jedes Sensorereignis einen einzelnen Wert bereit. In Tabelle 1 sind die Positionssensoren zusammengefasst, die von der Android-Plattform unterstützt werden.

Tabelle 1 Positionssensoren, die auf der Android-Plattform unterstützt werden

¹ Dieser Sensor wurde in Android 2.2 (API-Level 8) eingestellt und in Android 4.4W (API-Level 20) wurde er eingestellt. Das Sensor-Framework bietet alternative Methoden zum Erfassen der Geräteausrichtung. Diese werden unter Geräteausrichtung berechnen erläutert.

² Einige Näherungssensoren bieten nur Binärwerte für Nah- und Fernverbindungen.

Vektor für den Spielrotationsvektor verwenden

Der Vektor für die Spielrotation ist mit dem Rotationsvektorsensor identisch, verwendet jedoch nicht das geomagnetische Feld. Daher zeigt die Y-Achse nicht nach Norden, sondern auf einen anderen Bezug. Dieser Bezug kann um die gleiche Größenordnung wie das Gyroskop um die Z-Achse verschoben werden.

Da der Vektorsensor der Spielrotation das Magnetfeld nicht verwendet, sind relative Rotationen genauer und werden nicht durch Veränderungen des Magnetfelds beeinflusst. Verwenden Sie diesen Sensor in einem Spiel, wenn es Ihnen nicht wichtig ist, wo Norden ist, und der normale Rotationsvektor Ihre Anforderungen nicht erfüllt, da er vom Magnetfeld abhängig ist.

Der folgende Code zeigt, wie Sie eine Instanz des Standardsensors für Spielrotationen abrufen:

private lateinit var sensorManager: SensorManager
private var sensor: Sensor? = null
...
sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager
sensor = sensorManager.getDefaultSensor(Sensor.TYPE_GAME_ROTATION_VECTOR)

private SensorManager sensorManager;
private Sensor sensor;
...
sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
sensor = sensorManager.getDefaultSensor(Sensor.TYPE_GAME_ROTATION_VECTOR);

Geomagnetischen Rotationsvektorsensor verwenden

Der geomagnetische Rotationsvektorsensor ist dem Drehvektorsensor ähnlich, verwendet jedoch kein Gyroskop. Die Genauigkeit dieses Sensors ist geringer als beim normalen Rotationsvektorsensor, aber der Stromverbrauch wird reduziert. Verwenden Sie diesen Sensor nur, wenn Sie im Hintergrund Informationen zur Rotation erfassen möchten, ohne den Akku zu stark zu beanspruchen. Dieser Sensor ist am nützlichsten, wenn er in Verbindung mit einer Batchverarbeitung verwendet wird.

Der folgende Code zeigt, wie Sie eine Instanz des standardmäßigen Vektors für die geomagnetische Rotation abrufen:

private lateinit var sensorManager: SensorManager
private var sensor: Sensor? = null
...
sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager
sensor = sensorManager.getDefaultSensor(Sensor.TYPE_GEOMAGNETIC_ROTATION_VECTOR)

private SensorManager sensorManager;
private Sensor sensor;
...
sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
sensor = sensorManager.getDefaultSensor(Sensor.TYPE_GEOMAGNETIC_ROTATION_VECTOR);

Geräteausrichtung berechnen

Durch Berechnung der Geräteausrichtung lässt sich die Position des Geräts relativ zum Bezugsrahmen der Erde (insbesondere zum magnetischen Nordpol) beobachten. Der folgende Code zeigt, wie du die Ausrichtung eines Geräts berechnen kannst:

private lateinit var sensorManager: SensorManager
...
// Rotation matrix based on current readings from accelerometer and magnetometer.
val rotationMatrix = FloatArray(9)
SensorManager.getRotationMatrix(rotationMatrix, null, accelerometerReading, magnetometerReading)

// Express the updated rotation matrix as three orientation angles.
val orientationAngles = FloatArray(3)
SensorManager.getOrientation(rotationMatrix, orientationAngles)

private SensorManager sensorManager;
...
// Rotation matrix based on current readings from accelerometer and magnetometer.
final float[] rotationMatrix = new float[9];
SensorManager.getRotationMatrix(rotationMatrix, null,
    accelerometerReading, magnetometerReading);

// Express the updated rotation matrix as three orientation angles.
final float[] orientationAngles = new float[3];
SensorManager.getOrientation(rotationMatrix, orientationAngles);

Das System berechnet die Ausrichtungswinkel mithilfe des geomagnetischen Feldsensors eines Geräts in Kombination mit dem Beschleunigungsmesser des Geräts. Mithilfe dieser beiden Hardwaresensoren liefert das System Daten für die folgenden drei Ausrichtungswinkel:

• Azimut (Grad der Drehung um die -z-Achse). Das ist der Winkel zwischen der aktuellen Kompassrichtung des Geräts und dem magnetischen Norden. Wenn die obere Kante des Geräts nach Norden zeigt, beträgt der Azimut 0 Grad. Wenn die obere Kante nach Süden zeigt, beträgt der Azimut 180 Grad. Wenn die obere Kante nach Osten zeigt, beträgt der Azimut 90 Grad. Wenn die obere Kante nach Westen zeigt, beträgt der Azimut 270 Grad.
• Neigung (Grad der Drehung um die x-Achse). Dies ist der Winkel zwischen einer Ebene, die parallel zum Bildschirm des Geräts ist, und einer Ebene, die parallel zum Boden ist. Wenn du das Gerät parallel zum Boden hältst, die Unterkante dir am nächsten liegt, und die obere Kante des Geräts zum Boden neigst, wird der Neigungswinkel positiv. Durch eine Neigung in die entgegengesetzte Richtung, d. h. die obere Kante des Geräts weg vom Boden, wird der Neigungswinkel negativ beeinflusst. Der Wertebereich liegt zwischen -90 Grad und 90 Grad.
• Drehung (Drehung um die y-Achse). Dies ist der Winkel zwischen einer Ebene, die senkrecht zum Bildschirm des Geräts steht, und einer Ebene, die senkrecht zum Boden ist. Wenn du das Gerät parallel zum Boden hältst, die Unterkante dir am nächsten liegt, und die linke Seite des Geräts zum Boden neigst, wird der Rollwinkel positiv. Durch Neigen in die entgegengesetzte Richtung, d. h. durch Bewegen des rechten Geräterands zum Boden, wird der Rollwinkel negativ. Der Wertebereich liegt zwischen -180 Grad und 180 Grad.

Hinweis:Die Rolldefinition des Sensors wurde geändert und spiegelt die überwiegende Mehrheit der Implementierungen im Geosensor-System wider.

Beachten Sie, dass für diese Winkel ein anderes Koordinatensystem als in der Luftfahrt verwendet wird (Gier-, Neigungs- und Rollwinkel). In der Luftfahrt befindet sich die x-Achse an der langen Seite des Flugzeugs vom Heck bis zur Nase.

Der Ausrichtungssensor leitet seine Daten ab, indem er die Sensorrohdaten des Beschleunigungsmessers und des Sensors für das geomagnetische Feld verarbeitet. Aufgrund der aufwendigen Verarbeitung verschlechtert sich die Genauigkeit und Präzision des Ausrichtungssensors. Dieser Sensor ist nur dann zuverlässig, wenn der Rollwinkel 0 beträgt. Daher wurde der Ausrichtungssensor in Android 2.2 (API-Level 8) und der Ausrichtungssensortyp in Android 4.4W (API-Level 20) eingestellt. Anstatt Rohdaten aus dem Ausrichtungssensor zu verwenden, empfehlen wir, die Methode getRotationMatrix() in Verbindung mit der Methode getOrientation() zu verwenden, um Ausrichtungswerte zu berechnen, wie im folgenden Codebeispiel gezeigt. Dabei können Sie mit der Methode remapCoordinateSystem() die Ausrichtungswerte in den Referenzrahmen Ihrer Anwendung übersetzen.

class SensorActivity : Activity(), SensorEventListener {

    private lateinit var sensorManager: SensorManager
    private val accelerometerReading = FloatArray(3)
    private val magnetometerReading = FloatArray(3)

    private val rotationMatrix = FloatArray(9)
    private val orientationAngles = FloatArray(3)

    public override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.main)
        sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager
    }

    override fun onAccuracyChanged(sensor: Sensor, accuracy: Int) {
        // Do something here if sensor accuracy changes.
        // You must implement this callback in your code.
    }

    override fun onResume() {
        super.onResume()

        // Get updates from the accelerometer and magnetometer at a constant rate.
        // To make batch operations more efficient and reduce power consumption,
        // provide support for delaying updates to the application.
        //
        // In this example, the sensor reporting delay is small enough such that
        // the application receives an update before the system checks the sensor
        // readings again.
        sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER)?.also { accelerometer ->
            sensorManager.registerListener(
                    this,
                    accelerometer,
                    SensorManager.SENSOR_DELAY_NORMAL,
                    SensorManager.SENSOR_DELAY_UI
            )
        }
        sensorManager.getDefaultSensor(Sensor.TYPE_MAGNETIC_FIELD)?.also { magneticField ->
            sensorManager.registerListener(
                    this,
                    magneticField,
                    SensorManager.SENSOR_DELAY_NORMAL,
                    SensorManager.SENSOR_DELAY_UI
            )
        }
    }

    override fun onPause() {
        super.onPause()

        // Don't receive any more updates from either sensor.
        sensorManager.unregisterListener(this)
    }

    // Get readings from accelerometer and magnetometer. To simplify calculations,
    // consider storing these readings as unit vectors.
    override fun onSensorChanged(event: SensorEvent) {
        if (event.sensor.type == Sensor.TYPE_ACCELEROMETER) {
            System.arraycopy(event.values, 0, accelerometerReading, 0, accelerometerReading.size)
        } else if (event.sensor.type == Sensor.TYPE_MAGNETIC_FIELD) {
            System.arraycopy(event.values, 0, magnetometerReading, 0, magnetometerReading.size)
        }
    }

    // Compute the three orientation angles based on the most recent readings from
    // the device's accelerometer and magnetometer.
    fun updateOrientationAngles() {
        // Update rotation matrix, which is needed to update orientation angles.
        SensorManager.getRotationMatrix(
                rotationMatrix,
                null,
                accelerometerReading,
                magnetometerReading
        )

        // "rotationMatrix" now has up-to-date information.

        SensorManager.getOrientation(rotationMatrix, orientationAngles)

        // "orientationAngles" now has up-to-date information.
    }
}

public class SensorActivity extends Activity implements SensorEventListener {

    private SensorManager sensorManager;
    private final float[] accelerometerReading = new float[3];
    private final float[] magnetometerReading = new float[3];

    private final float[] rotationMatrix = new float[9];
    private final float[] orientationAngles = new float[3];

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
    }

    @Override
    public void onAccuracyChanged(Sensor sensor, int accuracy) {
        // Do something here if sensor accuracy changes.
        // You must implement this callback in your code.
    }

    @Override
    protected void onResume() {
        super.onResume();

        // Get updates from the accelerometer and magnetometer at a constant rate.
        // To make batch operations more efficient and reduce power consumption,
        // provide support for delaying updates to the application.
        //
        // In this example, the sensor reporting delay is small enough such that
        // the application receives an update before the system checks the sensor
        // readings again.
        Sensor accelerometer = sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);
        if (accelerometer != null) {
            sensorManager.registerListener(this, accelerometer,
                SensorManager.SENSOR_DELAY_NORMAL, SensorManager.SENSOR_DELAY_UI);
        }
        Sensor magneticField = sensorManager.getDefaultSensor(Sensor.TYPE_MAGNETIC_FIELD);
        if (magneticField != null) {
            sensorManager.registerListener(this, magneticField,
                SensorManager.SENSOR_DELAY_NORMAL, SensorManager.SENSOR_DELAY_UI);
        }
    }

    @Override
    protected void onPause() {
        super.onPause();

        // Don't receive any more updates from either sensor.
        sensorManager.unregisterListener(this);
    }

    // Get readings from accelerometer and magnetometer. To simplify calculations,
    // consider storing these readings as unit vectors.
    @Override
    public void onSensorChanged(SensorEvent event) {
        if (event.sensor.getType() == Sensor.TYPE_ACCELEROMETER) {
          System.arraycopy(event.values, 0, accelerometerReading,
              0, accelerometerReading.length);
        } else if (event.sensor.getType() == Sensor.TYPE_MAGNETIC_FIELD) {
            System.arraycopy(event.values, 0, magnetometerReading,
                0, magnetometerReading.length);
        }
    }

    // Compute the three orientation angles based on the most recent readings from
    // the device's accelerometer and magnetometer.
    public void updateOrientationAngles() {
        // Update rotation matrix, which is needed to update orientation angles.
        SensorManager.getRotationMatrix(rotationMatrix, null,
            accelerometerReading, magnetometerReading);

        // "rotationMatrix" now has up-to-date information.

        SensorManager.getOrientation(rotationMatrix, orientationAngles);

        // "orientationAngles" now has up-to-date information.
    }
}

Normalerweise müssen Sie keine Datenverarbeitung oder Filterung der Rohausrichtungswinkel des Geräts vornehmen, es sei denn, das Koordinatensystem des Sensors wird in den Referenzrahmen Ihrer Anwendung übersetzt.

Sensor für geomagnetisches Feld verwenden

Mit dem Sensor für das geomagnetische Feld können Sie Veränderungen im Magnetfeld der Erde erkennen. Der folgende Code zeigt, wie Sie eine Instanz des Standardsensors für das geomagnetische Feld abrufen:

private lateinit var sensorManager: SensorManager
private var sensor: Sensor? = null
...
sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager
sensor = sensorManager.getDefaultSensor(Sensor.TYPE_MAGNETIC_FIELD)

private SensorManager sensorManager;
private Sensor sensor;
...
sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
sensor = sensorManager.getDefaultSensor(Sensor.TYPE_MAGNETIC_FIELD);

Hinweis : Wenn Ihre App auf Android 12 (API-Level 31) oder höher ausgerichtet ist, ist dieser Sensor ratenbegrenzt.

Dieser Sensor liefert für jede der drei Koordinatenachsen Rohdaten zur Feldstärke in μT. Normalerweise müssen Sie diesen Sensor nicht direkt verwenden. Stattdessen können Sie den Rotationsvektorsensor zur Bestimmung der Rohdrehbewegung verwenden oder den Beschleunigungsmesser und den Sensor für das geomagnetische Feld in Verbindung mit der Methode getRotationMatrix() verwenden, um die Rotations- und Neigungsmatrix zu erhalten. Anschließend können Sie diese Matrizen mit den Methoden getOrientation() und getInclination() verwenden, um Daten zu Azimut und geomagnetischer Neigung zu erhalten.

Hinweis : Beim Testen Ihrer App können Sie die Genauigkeit des Sensors verbessern, indem Sie das Gerät im Format einer Acht bewegen.

Nicht kalibriertes Magnetometer verwenden

Das nicht kalibrierte Magnetometer ähnelt dem geomagnetischen Feldsensor, mit der Ausnahme, dass das Magnetfeld nicht auf Harteisen kalibriert wird. Die Werkskalibrierung und Temperaturkompensation werden weiterhin auf das Magnetfeld angewendet. Das nicht kalibrierte Magnetometer ist nützlich für schlechte Harteisenschätzungen. Im Allgemeinen liegt geomagneticsensor_event.values[0] nahe bei uncalibrated_magnetometer_event.values[0] - uncalibrated_magnetometer_event.values[3]. Das heißt:

calibrated_x ~= uncalibrated_x - bias_estimate_x

Hinweis:Nicht kalibrierte Sensoren liefern mehr Rohdaten und können eine gewisse Verzerrung enthalten, aber ihre Messungen enthalten weniger Abweichungen aufgrund von Korrekturen, die durch die Kalibrierung vorgenommen wurden. Einige Anwendungen bevorzugen diese nicht kalibrierten Ergebnisse möglicherweise als reibungslosere und zuverlässigere Ergebnisse. Wenn eine Anwendung beispielsweise versucht, ihre eigene Sensorfusion durchzuführen, kann die Einführung von Kalibrierungen die Ergebnisse verzerren.

Zusätzlich zum Magnetfeld liefert das nicht kalibrierte Magnetometer auch die geschätzte Verzerrung durch Harteisen auf jeder Achse. Der folgende Code zeigt, wie Sie eine Instanz des nicht kalibrierten Standard-Magnetometers abrufen:

private lateinit var sensorManager: SensorManager
private var sensor: Sensor? = null
...
sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager
sensor = sensorManager.getDefaultSensor(Sensor.TYPE_MAGNETIC_FIELD_UNCALIBRATED)

private SensorManager sensorManager;
private Sensor sensor;
...
sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
sensor = sensorManager.getDefaultSensor(Sensor.TYPE_MAGNETIC_FIELD_UNCALIBRATED);

Näherungssensor verwenden

Mit dem Näherungssensor können Sie bestimmen, wie weit ein Objekt von einem Gerät entfernt ist. Der folgende Code zeigt, wie Sie eine Instanz des Standard-Näherungssensors abrufen:

private lateinit var sensorManager: SensorManager
private var sensor: Sensor? = null
...
sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager
sensor = sensorManager.getDefaultSensor(Sensor.TYPE_PROXIMITY)

private SensorManager sensorManager;
private Sensor sensor;
...
sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
sensor = sensorManager.getDefaultSensor(Sensor.TYPE_PROXIMITY);

Der Näherungssensor wird normalerweise verwendet, um zu bestimmen, wie weit der Kopf einer Person vom Gesicht eines Mobilgeräts entfernt ist, z. B. wenn ein Nutzer einen Anruf tätigt oder empfängt. Die meisten Näherungssensoren geben die absolute Entfernung in cm zurück, einige geben jedoch nur nahe und große Werte zurück.

Hinweis:Bei einigen Gerätemodellen befindet sich der Näherungssensor unter dem Bildschirm. Dies kann dazu führen, dass ein blinkender Punkt auf dem Bildschirm erscheint, wenn er aktiviert ist, während das Display eingeschaltet ist.

Der folgende Code zeigt, wie Sie den Näherungssensor verwenden:

class SensorActivity : Activity(), SensorEventListener {

    private lateinit var sensorManager: SensorManager
    private var proximity: Sensor? = null

    public override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.main)

        // Get an instance of the sensor service, and use that to get an instance of
        // a particular sensor.
        sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager
        proximity = sensorManager.getDefaultSensor(Sensor.TYPE_PROXIMITY)
    }

    override fun onAccuracyChanged(sensor: Sensor, accuracy: Int) {
        // Do something here if sensor accuracy changes.
    }

    override fun onSensorChanged(event: SensorEvent) {
        val distance = event.values[0]
        // Do something with this sensor data.
    }

    override fun onResume() {
        // Register a listener for the sensor.
        super.onResume()

        proximity?.also { proximity ->
            sensorManager.registerListener(this, proximity, SensorManager.SENSOR_DELAY_NORMAL)
        }
    }

    override fun onPause() {
        // Be sure to unregister the sensor when the activity pauses.
        super.onPause()
        sensorManager.unregisterListener(this)
    }
}

public class SensorActivity extends Activity implements SensorEventListener {
    private SensorManager sensorManager;
    private Sensor proximity;

    @Override
    public final void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);

        // Get an instance of the sensor service, and use that to get an instance of
        // a particular sensor.
        sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
        proximity = sensorManager.getDefaultSensor(Sensor.TYPE_PROXIMITY);
    }

    @Override
    public final void onAccuracyChanged(Sensor sensor, int accuracy) {
        // Do something here if sensor accuracy changes.
    }

    @Override
    public final void onSensorChanged(SensorEvent event) {
        float distance = event.values[0];
        // Do something with this sensor data.
    }

    @Override
    protected void onResume() {
        // Register a listener for the sensor.
        super.onResume();
        sensorManager.registerListener(this, proximity, SensorManager.SENSOR_DELAY_NORMAL);
      }

    @Override
    protected void onPause() {
        // Be sure to unregister the sensor when the activity pauses.
        super.onPause();
        sensorManager.unregisterListener(this);
    }
}

Hinweis:Einige Näherungssensoren geben Binärwerte für "in der Nähe" oder "weit" zurück. In diesem Fall meldet der Sensor in der Regel seinen maximalen Bereich im entfernten Zustand und einen niedrigeren Wert im nahen Zustand. In der Regel ist der weit entfernte Wert größer als 5 cm, kann aber von Sensor zu Sensor variieren. Sie können die maximale Reichweite eines Sensors mit der Methode getMaximumRange() bestimmen.

Weitere Informationen

• Sensoren
• Sensoren
• Bewegungssensoren
• Umgebungssensoren