Positionssensoren

Die Android-Plattform bietet zwei Sensoren, mit denen Sie die Position eines Geräts bestimmen können: den geomagnetischen Feldsensor und den Beschleunigungsmesser. Die Android-Plattform bietet auch einen Sensor, mit dem Sie ermitteln können, wie nah sich die Vorderseite eines Geräts an einem Objekt befindet (Näherungssensor). Der Sensor für das geomagnetische Feld und der Näherungssensor sind hardwarebasiert. Die meisten Smartphone- und Tablet-Hersteller verbauen einen Sensor für das geomagnetische Feld. Ebenso verwenden Mobiltelefonhersteller in der Regel einen Näherungssensor, um zu erkennen, wann ein Mobiltelefon nah am Gesicht eines Nutzers gehalten wird (z. B. während eines Telefonats). Um die Ausrichtung eines Geräts zu bestimmen, können Sie die Messwerte des Beschleunigungsmessers und des geomagnetischen Feldsensors des Geräts verwenden.

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

Positionssensoren sind nützlich, um die physische Position eines Geräts im Bezugssystem der Welt zu 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 in Bezug auf den 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 Stoßen zu erfassen. 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. Der Sensor für das geomagnetische Feld liefert beispielsweise Werte für die Stärke des geomagnetischen Felds für jede der drei Koordinatenachsen während eines einzelnen Sensorereignisses. Ebenso misst der Beschleunigungsmesser die Beschleunigung, die während eines Sensorereignisses auf das Gerät wirkt. Weitere Informationen zu den von Sensoren verwendeten Koordinatensystemen finden Sie unter Sensor-Koordinatensysteme. Der Näherungssensor liefert für jedes Sensorereignis einen einzelnen Wert. In Tabelle 1 sind die Positionssensoren zusammengefasst, die auf der Android-Plattform unterstützt werden.

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

Sensor Sensordaten Beschreibung Maßeinheiten
TYPE_GAME_ROTATION_VECTOR SensorEvent.values[0] Komponente des Rotationsvektors entlang der X-Achse (x * sin(θ/2)). Einheitenlos
SensorEvent.values[1] Komponente des Rotationsvektors entlang der Y-Achse (y * sin(θ/2)).
SensorEvent.values[2] Komponente des Rotationsvektors entlang der Z-Achse (z * sin(θ/2)).
TYPE_GEOMAGNETIC_ROTATION_VECTOR SensorEvent.values[0] Komponente des Rotationsvektors entlang der X-Achse (x * sin(θ/2)). Einheitenlos
SensorEvent.values[1] Komponente des Rotationsvektors entlang der Y-Achse (y * sin(θ/2)).
SensorEvent.values[2] Komponente des Rotationsvektors entlang der Z-Achse (z * sin(θ/2)).
TYPE_MAGNETIC_FIELD SensorEvent.values[0] Stärke des geomagnetischen Felds entlang der X‑Achse. μT
SensorEvent.values[1] Stärke des geomagnetischen Felds entlang der Y-Achse.
SensorEvent.values[2] Stärke des geomagnetischen Felds entlang der Z-Achse.
TYPE_MAGNETIC_FIELD_UNCALIBRATED SensorEvent.values[0] Stärke des geomagnetischen Felds (ohne Hard-Iron-Kalibrierung) entlang der X-Achse. μT
SensorEvent.values[1] Stärke des geomagnetischen Felds (ohne Hard-Iron-Kalibrierung) entlang der Y-Achse.
SensorEvent.values[2] Stärke des geomagnetischen Felds (ohne Hard-Iron-Kalibrierung) entlang der Z-Achse.
SensorEvent.values[3] Schätzung der Eisenverzerrung entlang der x-Achse.
SensorEvent.values[4] Schätzung des Eisenbias entlang der Y-Achse.
SensorEvent.values[5] Schätzung des Eisenbias entlang der Z-Achse.
TYPE_ORIENTATION1 SensorEvent.values[0] Azimut (Winkel um die Z-Achse). Grad
SensorEvent.values[1] Neigung (Winkel um die X-Achse).
SensorEvent.values[2] Rollen (Winkel um die Y-Achse).
TYPE_PROXIMITY SensorEvent.values[0] Entfernung vom Objekt.2 cm

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

2 Einige Näherungssensoren liefern nur binäre Werte, die „nah“ und „fern“ darstellen.

Sensor für Spielrotationsvektor verwenden

Der Sensor für den Spielrotationsvektor ist mit dem Sensor für den Rotationsvektor identisch, verwendet jedoch nicht das geomagnetische Feld. Die Y-Achse zeigt daher nicht nach Norden, sondern auf eine andere Referenz. Diese Referenz darf um dieselbe Größenordnung abweichen wie die Drift des Gyroskops um die Z-Achse.

Da der Sensor für den Spielrotationsvektor das Magnetfeld nicht verwendet, sind relative Rotationen genauer und werden nicht durch Änderungen des Magnetfelds beeinflusst. Verwenden Sie diesen Sensor in einem Spiel, wenn Sie nicht wissen müssen, wo Norden ist, und der normale Rotationsvektor aufgrund seiner Abhängigkeit vom Magnetfeld nicht Ihren Anforderungen entspricht.

Der folgende Code zeigt, wie Sie eine Instanz des Standard-Game-Rotationsvektorsensors abrufen:

Kotlin

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)

Java

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

Geomagnetischen Rotationsvektorsensor verwenden

Der Sensor für den geomagnetischen Rotationsvektor ähnelt dem Sensor für den Rotationsvektor, verwendet aber kein Gyroskop. Die Genauigkeit dieses Sensors ist geringer als beim normalen Sensor für den Rotationsvektor, aber der Stromverbrauch ist geringer. Verwenden Sie diesen Sensor nur, wenn Sie Rotationsinformationen im Hintergrund erfassen möchten, ohne zu viel Akku zu verbrauchen. Dieser Sensor ist am nützlichsten, wenn er in Verbindung mit Batching verwendet wird.

Der folgende Code zeigt, wie Sie eine Instanz des Standard-Sensors für geomagnetische Rotationsvektoren abrufen:

Kotlin

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)

Java

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

Wenn Sie die Ausrichtung eines Geräts berechnen, können Sie die Position des Geräts relativ zum Bezugssystem der Erde (insbesondere zum magnetischen Nordpol) überwachen. Der folgende Code zeigt, wie Sie die Ausrichtung eines Geräts berechnen:

Kotlin

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)

Java

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) Dies ist der Winkel zwischen der aktuellen Kompassrichtung des Geräts und dem magnetischen Norden. Wenn die Oberkante des Geräts nach magnetisch Norden zeigt, beträgt der Azimut 0 Grad. Wenn die Oberkante nach Süden zeigt, beträgt der Azimut 180 Grad. Wenn die obere Kante nach Osten zeigt, beträgt der Azimut 90 Grad. Wenn sie nach Westen zeigt, beträgt der Azimut 270 Grad.
  • Neigung (Drehwinkel um die X-Achse in Grad) Dies ist der Winkel zwischen einer Ebene, die parallel zum Bildschirm des Geräts verläuft, und einer Ebene, die parallel zum Boden verläuft. Wenn Sie das Gerät parallel zum Boden halten und die untere Kante am nächsten zu Ihnen ist und Sie die obere Kante des Geräts in Richtung Boden neigen, wird der Neigungswinkel positiv. Wenn Sie das Gerät in die entgegengesetzte Richtung neigen, also die obere Kante 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) Dies ist der Winkel zwischen einer Ebene, die senkrecht zum Display des Geräts verläuft, und einer Ebene, die senkrecht zum Boden verläuft. Wenn Sie das Gerät parallel zum Boden halten und die Unterkante am nächsten zu Ihnen ist und Sie die linke Kante des Geräts zum Boden hin neigen, wird der Rollwinkel positiv. Wenn Sie das Gerät in die entgegengesetzte Richtung neigen, also die rechte Kante des Geräts in Richtung Boden bewegen, wird der Rollwinkel negativ. Der Wertebereich liegt zwischen -180 und 180 Grad.

Hinweis:Die Definition des Rollsensors wurde geändert, um der großen Mehrheit der Implementierungen im Geosensor-Ökosystem zu entsprechen.

Die Winkel basieren auf einem anderen Koordinatensystem als dem, das in der Luftfahrt für Gieren, Nicken und Rollen verwendet wird. Im Luftfahrtsystem verläuft die X-Achse entlang der Längsseite des Flugzeugs, vom Heck zur Nase.

Der Orientierungssensor leitet seine Daten aus der Verarbeitung der Rohsensordaten des Beschleunigungsmessers und des geomagnetischen Feldsensors ab. Aufgrund der intensiven Verarbeitung, die erforderlich ist, werden die Genauigkeit und Präzision des Orientierungssensors beeinträchtigt. Dieser Sensor ist nur 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 Orientierungssensor zu verwenden, empfehlen wir, die Methode getRotationMatrix() in Verbindung mit der Methode getOrientation() zu verwenden, um Orientierungswerte zu berechnen, wie im folgenden Codebeispiel gezeigt. Im Rahmen dieses Prozesses können Sie die Methode remapCoordinateSystem() verwenden, um die Ausrichtungswerte in das Bezugssystem Ihrer Anwendung zu übersetzen.

Kotlin

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.
    }
}

Java

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. Sie müssen lediglich das Koordinatensystem des Sensors in das Bezugssystem Ihrer Anwendung übertragen.

Geomagnetischen Feldsensor verwenden

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

Kotlin

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

Java

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, wird die Aktualisierungsrate dieses Sensors begrenzt.

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 rohe Drehbewegung zu ermitteln, oder den Beschleunigungsmesser und den geomagnetischen Feldsensor in Verbindung mit der Methode getRotationMatrix(), um die Rotationsmatrix und die Neigungsmatrix zu erhalten. Anschließend können Sie diese Matrizen mit den Methoden getOrientation() und getInclination() verwenden, um Daten zu Azimut und geomagnetischer Inklination abzurufen.

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

Nicht kalibriertes Magnetometer verwenden

Das nicht kalibrierte Magnetometer ähnelt dem Sensor für das geomagnetische Feld, mit der Ausnahme, dass keine Hard-Iron-Kalibrierung auf das Magnetfeld angewendet wird. Die werkseitige Kalibrierung und die Temperaturkompensation werden weiterhin auf das Magnetfeld angewendet. Der nicht kalibrierte Magnetometer ist nützlich, um schlechte Schätzungen von hartem Eisen zu korrigieren. Im Allgemeinen liegt 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 mehr Rohdaten und können einige Abweichungen aufweisen. Ihre Messungen enthalten jedoch weniger Sprünge durch Korrekturen, die durch die Kalibrierung angewendet werden. Einige Anwendungen bevorzugen möglicherweise diese nicht kalibrierten Ergebnisse, da sie gleichmäßiger und zuverlässiger sind. Wenn eine Anwendung beispielsweise versucht, eigene Sensorfusion durchzuführen, können Kalibrierungen die Ergebnisse verzerren.

Zusätzlich zum Magnetfeld liefert das nicht kalibrierte Magnetometer auch die geschätzte Hard-Iron-Vorspannung auf jeder Achse. Der folgende Code zeigt, wie Sie eine Instanz des standardmäßigen unkalibrierten Magnetometers abrufen:

Kotlin

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)

Java

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. Der folgende Code zeigt, wie Sie eine Instanz des Standard-Näherungssensors abrufen:

Kotlin

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

Java

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 ermitteln, wie weit der Kopf einer Person vom Display eines Mobilgeräts entfernt ist, z. B. wenn ein Nutzer einen Anruf tätigt oder entgegennimmt. Die meisten Näherungssensoren geben den absoluten Abstand in Zentimetern zurück, einige jedoch nur die Werte „Nah“ und „Fern“.

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

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

Kotlin

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)
    }
}

Java

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 „fern“ darstellen. In diesem Fall meldet der Sensor in der Regel seinen maximalen Bereichswert im fernen Zustand und einen geringeren Wert im nahen Zustand. Normalerweise liegt der Wert für „Entfernt“ bei > 5 cm, kann aber je nach Sensor variieren. Mit der Methode getMaximumRange() können Sie den maximalen Bereich eines Sensors ermitteln.

Lesen Sie auch

Zurück
Bewegungssensoren
Weiter
Umgebungssensoren