Positionssensoren

Die Android-Plattform bietet zwei Sensoren, mit denen Sie die Position eines Geräts bestimmen können: den Geomagnetfeldsensor und den Beschleunigungsmesser. Die Android-Plattform bietet auch einen Sensor, mit dem Sie feststellen können, wie nah sich das Display eines Geräts an einem Objekt befindet (Näherungssensor). Der geomagnetische Sensor und der Näherungssensor sind hardwarebasiert. Die meisten Smartphone- und Tablethersteller statten ihre Geräte mit einem Sensor für das geomagnetische Feld aus. Ebenso sind in Smartphones in der Regel Näherungssensoren enthalten, die erkennen, wenn ein Smartphone nah am Gesicht eines Nutzers gehalten wird (z. B. während eines Telefongesprächs). Zur Bestimmung der Ausrichtung eines Geräts können Sie die Messwerte des Beschleunigungsmessers und des Geomagnetfeldsensors des Geräts verwenden.

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

Mithilfe von Positionssensoren lässt sich die physische Position eines Geräts im Weltkoordinatensystem bestimmen. So können Sie beispielsweise den Sensor für das geomagnetische Feld in Kombination 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 Bezugssystem Ihrer Anwendung zu bestimmen. Positionssensoren werden in der Regel nicht verwendet, um Gerätebewegungen wie Schütteln, Neigen oder Vor-/Zurückbewegen zu überwachen. Weitere Informationen finden Sie unter Bewegungssensoren.

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

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

¹Dieser Sensor wurde in Android 2.2 (API-Level 8) eingestellt und dieser Sensortyp wurde in Android 4.4W (API-Level 20) eingestellt. Das Sensor-Framework bietet alternative Methoden zum Ermitteln der Geräteausrichtung, die unter Ausrichtung des Geräts berechnen beschrieben werden.

² Einige Näherungssensoren liefern nur binäre Werte, die „Nah“ und „Weit“ darstellen.

Vektorsensor für die Spieldrehung verwenden

Der Vektorsensor für die Drehung in Spielen ist mit dem Vektorsensor für die Drehung identisch, mit der Ausnahme, dass er nicht das geomagnetische Feld verwendet. Daher zeigt die Y-Achse nicht nach Norden, sondern auf eine andere Referenz. Diese Referenz darf um denselben Betrag driften wie das Gyroskop um die Z‑Achse.

Da der Vektorsensor für die Drehung des Spiels nicht das Magnetfeld verwendet, sind relative Drehungen genauer und nicht von Änderungen des Magnetfelds betroffen. Verwenden Sie diesen Sensor in einem Spiel, wenn Sie nicht wissen möchten, wo Norden ist, und der normale Drehvektor aufgrund seiner Abhängigkeit vom Magnetfeld nicht Ihren Anforderungen entspricht.

Im folgenden Code wird gezeigt, wie Sie eine Instanz des Standardsensors für den Drehvektor des Spiels 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 Drehvektorsensor verwenden

Der geomagnetische Drehvektorsensor ähnelt dem Drehvektorsensor, verwendet aber kein Gyroskop. Die Genauigkeit dieses Sensors ist geringer als die des normalen Drehvektorsensors, aber der Stromverbrauch ist reduziert. Verwenden Sie diesen Sensor nur, wenn Sie Informationen zur Drehung im Hintergrund erfassen möchten, ohne zu viel Akku zu verbrauchen. Dieser Sensor ist am besten geeignet, wenn er in Kombination mit Batching verwendet wird.

Im folgenden Code wird gezeigt, wie Sie eine Instanz des Standardsensors für den geomagnetischen Drehvektor 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);

Ausrichtung des Geräts berechnen

Durch die Berechnung der Ausrichtung eines Geräts können Sie die Position des Geräts relativ zum Referenzsystem der Erde (insbesondere zum magnetischen Nordpol) überwachen. Im folgenden Code wird gezeigt, wie die Ausrichtung eines Geräts berechnet wird:

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 anhand des geomagnetischen Feldsensors eines Geräts in Kombination mit dem Beschleunigungsmesser des Geräts. Anhand dieser beiden Hardwaresensoren liefert das System Daten für die folgenden drei Orientierungswinkel:

• Azimut (Drehwinkel um die -z-Achse in Grad). Das ist der Winkel zwischen der aktuellen Kompassrichtung des Geräts und dem magnetischen Norden. Wenn der obere Rand des Geräts zum magnetischen Norden zeigt, beträgt der Azimut 0 Grad. Wenn der obere Rand nach Süden zeigt, beträgt der Azimut 180 Grad. Wenn die Oberkante nach Osten zeigt, beträgt der Azimut 90 Grad. Wenn sie nach Westen zeigt, beträgt er 270 Grad.
• Neigung (Drehwinkel um die X-Achse) Das ist der Winkel zwischen einer Ebene, die parallel zum Display des Geräts ist, und einer Ebene, die parallel zum Boden ist. Wenn Sie das Gerät parallel zum Boden halten, wobei der untere Rand am nächsten zu Ihnen ist, und den oberen Rand des Geräts in Richtung Boden neigen, wird der Neigungswinkel positiv. Wenn Sie das Gerät in die entgegengesetzte Richtung neigen, also den oberen Rand des Geräts vom Boden weg bewegen, wird der Neigungswinkel negativ. Der Wertebereich liegt zwischen -90 und 90 Grad.
• Rollen (Drehwinkel um die Y-Achse) Das ist der Winkel zwischen einer Ebene, die senkrecht zum Display des Geräts steht, und einer Ebene, die senkrecht zum Boden steht. Wenn Sie das Gerät parallel zum Boden halten, wobei der untere Rand Ihnen am nächsten ist, und den linken Rand des Geräts in Richtung Boden neigen, wird der Rollwinkel positiv. Wenn Sie das Gerät in die entgegengesetzte Richtung neigen, also den rechten Rand des Geräts in Richtung Boden bewegen, wird der Rollwinkel negativ. Der Wertebereich liegt zwischen -180 und 180 Grad.

Hinweis:Die Definition der Rollung des Sensors wurde geändert, um der überwiegenden Mehrheit der Implementierungen im Geosensor-System zu entsprechen.

Beachten Sie, dass diese Winkel auf einem anderen Koordinatensystem beruhen als das in der Luftfahrt verwendete (für Gieren, Nicken und Rollen). Im Luftfahrtsystem verläuft die X-Achse entlang der Längsseite des Flugzeugs, vom Heck bis zur Nase.

Der Ausrichtungssensor leitet seine Daten durch die Verarbeitung der Rohdaten des Beschleunigungsmessers und des Geomagnetfeldsensors ab. Aufgrund der umfangreichen Verarbeitung sinkt die Genauigkeit des Ortungssensors. Insbesondere ist dieser Sensor nur dann zuverlässig, wenn der Rollwinkel 0 ist. Daher wurde der Ausrichtungssensor in Android 2.2 (API-Level 8) eingestellt und der Ausrichtungssensortyp in Android 4.4W (API-Level 20). Anstatt Rohdaten vom 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 die Methode remapCoordinateSystem() verwenden, um die Orientierungswerte in den Referenzrahmen Ihrer Anwendung umzuwandeln.

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 die Rohorientierungswinkel des Geräts nicht verarbeiten oder filtern, sondern nur das Koordinatensystem des Sensors in den Referenzrahmen Ihrer Anwendung umwandeln.

Geomagnetischen Sensor verwenden

Mit dem geomagnetischen Sensor können Sie Veränderungen des Erdmagnetfelds beobachten. Im folgenden Code wird gezeigt, 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 taktgesteuert.

Dieser Sensor liefert Rohdaten zur Feldstärke (in μT) für jede der drei Koordinatenachsen. Normalerweise müssen Sie diesen Sensor nicht direkt verwenden. Stattdessen können Sie den Rotationsvektorsensor verwenden, um die Rohrotationsbewegung zu bestimmen, oder den Beschleunigungsmesser und den Geomagnetfeldsensor in Kombination mit der Methode getRotationMatrix(), um die Rotationsmatrix und die Neigungsmatrix zu erhalten. Sie können diese Matrizen dann mit den Methoden getOrientation() und getInclination() verwenden, um Azimut- und geomagnetische Neigungsdaten zu erhalten.

Hinweis : Wenn Sie Ihre App testen, können Sie die Genauigkeit des Sensors verbessern, indem Sie das Gerät in einer Acht geschwenkt halten.

Unkalibrierten Magnetometer verwenden

Das nicht kalibrierte Magnetometer ähnelt dem Sensor für das geomagnetische Feld, mit der Ausnahme, dass das Magnetfeld nicht mit einem harten Eisen kalibriert wird. Die werksseitige Kalibrierung und Temperaturkompensation werden weiterhin auf das Magnetfeld angewendet. Der nicht kalibrierte Magnetometer ist nützlich, um schlechte Schätzungen von hartem Eisen zu verarbeiten. Im Allgemeinen ist geomagneticsensor_event.values[0] nahe bei uncalibrated_magnetometer_event.values[0] - uncalibrated_magnetometer_event.values[3]. Das bedeutet:

calibrated_x ~= uncalibrated_x - bias_estimate_x

Hinweis:Nicht kalibrierte Sensoren liefern Rohdaten und können eine gewisse Abweichung aufweisen. Ihre Messungen enthalten jedoch weniger Sprünge durch Korrekturen, die durch die Kalibrierung angewendet werden. Für einige Anwendungen sind diese nicht kalibrierten Ergebnisse möglicherweise geeigneter, da sie flüssiger und zuverlässiger sind. Wenn eine Anwendung beispielsweise versucht, eine eigene Sensorfusion durchzuführen, können Kalibrierungen die Ergebnisse verfälschen.

Neben dem Magnetfeld liefert das nicht kalibrierte Magnetometer auch die geschätzte Magnetfeldstörung durch hartes Eisen in jeder Achse. Im folgenden Code wird gezeigt, wie Sie eine Instanz des standardmäßigen nicht kalibrierten 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 feststellen, wie weit ein Objekt von einem Gerät entfernt ist. Im folgenden Code wird gezeigt, 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 in der Regel verwendet, um zu bestimmen, wie weit der Kopf einer Person vom Display eines Smartphones entfernt ist (z. B. wenn ein Nutzer einen Anruf startet oder empfängt). Die meisten Näherungssensoren geben die absolute Entfernung in Zentimetern zurück, einige jedoch nur Werte für „Nah“ und „Weit“.

Hinweis:Bei einigen Gerätemodellen befindet sich der Näherungssensor unter dem Display. Wenn er aktiviert ist, während das Display eingeschaltet ist, kann ein blinkender Punkt auf dem Display erscheinen.

Im folgenden Code wird gezeigt, wie der Näherungssensor verwendet wird:

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 zurück, die „nah“ oder „weit“ bedeuten. In diesem Fall meldet der Sensor in der Regel seinen maximalen Bereichswert im Fernmodus und einen niedrigeren Wert im Nahmodus. Normalerweise ist der Wert für „Weit“ größer als 5 cm. Dies kann jedoch von Sensor zu Sensor variieren. Mit der Methode getMaximumRange() können Sie den maximalen Bereich eines Sensors ermitteln.

Lesen Sie auch

• Sensoren
• Sensoren – Übersicht
• Bewegungssensoren
• Umgebungssensoren