Positionssensoren

Die Android-Plattform bietet zwei Sensoren, mit denen Sie die Position eines Geräts bestimmen können: den Sensor für geomagnetische Felder und den Beschleunigungsmesser. Die Android-Plattform bietet auch einen Näherungssensor, mit dem Sie feststellen können, wie nah die Vorderseite eines Geräts an einem Objekt ist. Der Sensor für geomagnetische Felder und der Näherungssensor sind hardwarebasiert. Die meisten Hersteller von Mobiltelefonen und Tablets bieten einen Sensor für geomagnetische Felder. Außerdem verwenden Hersteller von Mobiltelefonen in der Regel einen Näherungssensor, um festzustellen, wann ein Mobiltelefon nah am Gesicht eines Nutzers gehalten wird (z. B. während eines Telefonanrufs). Zur Bestimmung der Ausrichtung eines Geräts können Sie die Messwerte des Beschleunigungsmessers des Geräts und des Sensors für geomagnetische Felder verwenden.

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 bestimmen. Sie können beispielsweise den Sensor für geomagnetische Felder 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 Bezugsrahmen Ihrer App zu ermitteln. Positionssensoren werden in der Regel nicht zur Überwachung von Gerätebewegungen oder -bewegungen verwendet, z. B. Rütteln, Neigung oder Schub. Weitere Informationen finden Sie unter Bewegungssensoren.

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

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

Sensor Sensorereignisdaten Beschreibung Maßeinheiten
TYPE_GAME_ROTATION_VECTOR SensorEvent.values[0] Rotationsvektorkomponente entlang der x-Achse (x * sin(Θ/2)). Ohne Einheit
SensorEvent.values[1] Komponente des Rotationsvektors entlang der Y-Achse (y × sin(Θ/2)).
SensorEvent.values[2] Rotationsvektorkomponente entlang der z-Achse (z × sin(Θ/2)).
TYPE_GEOMAGNETIC_ROTATION_VECTOR SensorEvent.values[0] Rotationsvektorkomponente entlang der x-Achse (x * sin(Θ/2)). Ohne Einheit
SensorEvent.values[1] Komponente des Rotationsvektors entlang der Y-Achse (y × sin(Θ/2)).
SensorEvent.values[2] Rotationsvektorkomponente entlang der z-Achse (z × sin(Θ/2)).
TYPE_MAGNETIC_FIELD SensorEvent.values[0] Geomagnetische Feldstärke entlang der x-Achse. μT
SensorEvent.values[1] Geomagnetische Feldstärke entlang der Y-Achse.
SensorEvent.values[2] Geomagnetische Feldstärke entlang der z-Achse.
TYPE_MAGNETIC_FIELD_UNCALIBRATED SensorEvent.values[0] Geomagnetische Feldstärke (ohne Harteisenkalibrierung) entlang der x-Achse. μT
SensorEvent.values[1] Geomagnetische Feldstärke (ohne Harteisenkalibrierung) entlang der Y-Achse.
SensorEvent.values[2] Geomagnetische Feldstärke (ohne Harteisenkalibrierung) entlang der z-Achse.
SensorEvent.values[3] Schätzung der Eisenverzerrung entlang der x-Achse.
SensorEvent.values[4] Schätzung der Eisenverzerrung entlang der Y-Achse.
SensorEvent.values[5] Schätzung der Eisenverzerrung 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 Objekt2 cm

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

2 Einige Näherungssensoren liefern nur binäre Werte für nahe und weite Entfernungen.

Rotationsvektorsensor des Spiels verwenden

Der Rotationsvektorsensor ist mit dem Rotationsvektorsensor identisch, verwendet aber kein geomagnetisches Feld. Daher zeigt die Y-Achse nicht nach Norden, sondern auf einen anderen Bezug. Dieser Bezug kann in der gleichen Größenordnung wie das Gyroskop um die Z-Achse driften.

Da der Rotationsvektorsensor des Spiels das Magnetfeld nicht verwendet, sind relative Drehungen genauer und werden nicht von Änderungen des Magnetfelds beeinflusst. Verwenden Sie diesen Sensor in einem Spiel, wenn Norden für Sie nicht relevant ist und der normale Rotationsvektor aufgrund seiner Abhängigkeit vom Magnetfeld nicht Ihren Anforderungen entspricht.

Der folgende Code zeigt, wie Sie eine Instanz des Standardvektorsensors für die Spielerotation 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);

Sensor für geomagnetische Rotation verwenden

Der geomagnetische Rotationsvektorsensor ähnelt dem Rotationsvektorsensor, verwendet aber nicht das Gyroskop. Die Genauigkeit dieses Sensors ist geringer als die eines normalen Rotationsvektorsensors, dadurch wird aber der Stromverbrauch reduziert. Verwenden Sie diesen Sensor nur, wenn Sie Rotationsinformationen im Hintergrund erfassen möchten, ohne zu viel Akkukapazität zu verbrauchen. Dieser Sensor ist am nützlichsten in Verbindung mit Batchverarbeitung.

Der folgende Code zeigt, wie Sie eine Instanz des standardmäßigen geomagnetischen 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_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 dessen Position relativ zum Bezugsrahmen der Erde (insbesondere zum magnetischen Nordpol) beobachten. Der folgende Code zeigt, wie die Ausrichtung eines Geräts berechnet wird:

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 Sensors für geomagnetische Felder eines Geräts in Kombination mit dem Beschleunigungsmesser des Geräts. Mit diesen beiden Hardwaresensoren liefert das System Daten für die folgenden drei Ausrichtungswinkel:

  • Azimut (Drehungsgrade um die -z-Achse) Dies ist der Winkel zwischen der aktuellen Kompassrichtung des Geräts und dem magnetischen Norden. Wenn die obere Kante des Geräts magnetisch nach Norden zeigt, beträgt der Azimut 0 Grad. Wenn die obere Kante nach Süden zeigt, beträgt der Azimut 180 Grad. Gleichermaßen beträgt der Azimut 90 Grad und der obere Rand nach Westen 270 Grad.
  • Neigung (Drehungsgrad um die X-Achse). Dies ist der Winkel zwischen einer Ebene parallel zum Bildschirm des Geräts und einer Ebene parallel zum Boden. Wenn du das Gerät parallel zum Boden hältst, wobei die Unterkante dir am nächsten ist, und die obere Kante des Geräts zum Boden neigst, wird der Neigungswinkel positiv. Wenn Sie die Ansicht in die entgegengesetzte Richtung neigen, also die Oberkante des Geräts vom Boden wegbewegen, wird der Neigungswinkel negativ. Der Wertebereich liegt zwischen -90 und 90 Grad.
  • Neigen (Drehungsgrade um die Y-Achse) Dies ist der Winkel zwischen einer Ebene, die senkrecht zum Bildschirm des Geräts ist, und einer Ebene, die senkrecht zum Boden ist. Wenn du das Gerät parallel zum Boden hältst, wobei die Unterkante dir am nächsten ist, und die linke Kante des Geräts zum Boden neigst, wird der Rollwinkel positiv. Wird das Gerät in die entgegengesetzte Richtung neigen, also die rechte Kante des Geräts in Richtung Boden bewegt, wird der Rollwinkel negativ. Der Wertebereich liegt zwischen -180 und 180 Grad.

Hinweis:Die Definition von „Roll“ des Sensors hat sich geändert, um die überwiegende Mehrheit der Implementierungen in der Geosensoren-Umgebung widerzuspiegeln.

Beachten Sie, dass für diese Winkel ein anderes Koordinatensystem als in der Luftfahrt verwendet wird (Gier-, Nick- und Roll-Winkel). Im Luftfahrtsystem verläuft die x-Achse entlang der langen Seite des Flugzeugs, vom Heck bis zur Nase.

Der Ausrichtungssensor bezieht seine Daten, indem er die Sensorrohdaten aus dem Beschleunigungsmesser und dem Sensor für geomagnetische Felder verarbeitet. Aufgrund der aufwendigen Verarbeitung ist die Genauigkeit des Ausrichtungssensors geringer. Insbesondere ist dieser Sensor nur zuverlässig, wenn der Rollwinkel 0 ist. Daher wurde der Ausrichtungssensor in Android 2.2 (API-Level 8) und der Ausrichtungssensortyp in Android 4.4W (API-Level 20) eingestellt. Anstatt Rohdaten des Ausrichtungssensors zu verwenden, empfehlen wir, zum Berechnen von Ausrichtungswerten die Methode getRotationMatrix() in Verbindung mit der Methode getOrientation() zu verwenden, wie im folgenden Codebeispiel gezeigt. Im Rahmen dieses Vorgangs können Sie die Methode remapCoordinateSystem() verwenden, um die Ausrichtungswerte in den Referenzrahmen Ihrer Anwendung zu übertragen.

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 keine Datenverarbeitung oder Filterung der unbearbeiteten Ausrichtungswinkel des Geräts vornehmen, außer das Koordinatensystem des Sensors in den Bezugsrahmen Ihrer Anwendung zu übersetzen.

Geomagnetisches Feldsensor verwenden

Mit dem Sensor für geomagnetische Felder können Änderungen im Magnetfeld der Erde überwacht werden. Der folgende Code zeigt, wie Sie eine Instanz des Standardsensors für geomagnetische Felder 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, gilt für diesen Sensor eine Ratenbegrenzung.

Dieser Sensor liefert Feldstärke-Rohdaten (in μT) für jede der drei Koordinatenachsen. Normalerweise musst du diesen Sensor nicht direkt verwenden. Stattdessen können Sie den Rotationsvektorsensor verwenden, um die Rohbewegung der Rotation zu bestimmen, oder den Beschleunigungsmesser und den Sensor für geomagnetische Felder in Verbindung mit der getRotationMatrix()-Methode verwenden, um die Rotations- und Neigungsmatrix zu erhalten. Sie können diese Matrizen dann mit den Methoden getOrientation() und getInclination() verwenden, um Daten zur Azimut und geomagnetischen Neigung zu erhalten.

Hinweis : Beim Testen Ihrer App können Sie die Genauigkeit des Sensors verbessern, indem Sie das Gerät in einem Muster in einer 8 bewegen.

Nicht kalibriertes Magnetometer verwenden

Das nicht kalibrierte Magnetometer ähnelt dem Sensor für geomagnetische Felder, mit der Ausnahme, dass keine Harteisenkalibrierung auf das Magnetfeld angewendet wird. Die Werkskalibrierung und Temperaturkompensation werden weiterhin auf das Magnetfeld angewendet. Das nicht kalibrierte Magnetometer ist nützlich, um schlechte Eisenschätzungen durchzuführen. Im Allgemeinen liegt geomagneticsensor_event.values[0] in der Nähe von 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 Rohergebnisse und können eine gewisse Verzerrung enthalten. Ihre Messungen enthalten jedoch weniger Sprünge aufgrund von Korrekturen, die während der Kalibrierung vorgenommen wurden. Einige Anwendungen bevorzugen diese nicht kalibrierten Ergebnisse möglicherweise als flüssiger und zuverlässiger. Wenn eine Anwendung beispielsweise versucht, eine eigene Sensorfusion durchzuführen, können Kalibrierungen die Ergebnisse verzerren.

Zusätzlich zum Magnetfeld liefert das nicht kalibrierte Magnetometer auch die geschätzte Verzerrung durch hartes Eisen in jeder Achse. Der folgende Code zeigt, wie Sie eine Instanz des nicht kalibrierten Standardmagnetometers 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 ermitteln, 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 normalerweise verwendet, um zu ermitteln, 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 jedoch nur Nah- und weite Werte.

Hinweis:Bei einigen Gerätemodellen befindet sich der Näherungssensor unter dem Bildschirm. Daher kann ein blinkender Punkt auf dem Bildschirm angezeigt werden, wenn er bei eingeschaltetem Bildschirm aktiviert ist.

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äre Werte zurück, die „nah“ oder „weit“ stehen. In diesem Fall meldet der Sensor normalerweise seinen maximalen Bereichswert im fernen Zustand und einen niedrigeren Wert im nahen Zustand. In der Regel beträgt der Wert für die Entfernung größer als 5 cm, kann jedoch von Sensor zu Sensor variieren. Mit der Methode getMaximumRange() können Sie die maximale Reichweite eines Sensors ermitteln.

Weitere Informationen

Zurück
Bewegungssensoren
Weiter
Umgebungssensoren