Sensoren – Übersicht

Die meisten Android-Geräte haben integrierte Sensoren, die Bewegung, Ausrichtung und verschiedene Umgebungsbedingungen messen. Diese Sensoren liefern Rohdaten Genauigkeit und Genauigkeit. Sie sind nützlich, wenn Sie die dreidimensionale Gerätebewegung oder die oder Sie möchten Änderungen in der Umgebung in der Nähe eines Geräts beobachten. Beispiel: Ein Spiel kann Messwerte des Schwerkraftsensors eines Geräts aufzeichnen, um komplexe Nutzergesten abzuleiten. und Bewegungen wie Neigung, Schütteln, Drehen oder Schaukeln. Ebenso kann eine Wetter-App den Temperatur- und den Feuchtigkeitssensor eines Geräts verwenden, um den Taupunkt zu berechnen und anzugeben. Eine Reise-App kann den Sensor für das geomagnetische Feld und den Beschleunigungsmesser verwenden, um eine Kompasspeilung anzugeben.

Weitere Informationen finden Sie in den folgenden verwandten Ressourcen:

Die Android-Plattform unterstützt drei große Kategorien von Sensoren:

  • Bewegungssensoren

    Diese Sensoren messen Beschleunigungs- und Drehkräfte entlang von drei Achsen. Dieses Die Kategorie umfasst Beschleunigungsmesser, Schwerkraftsensoren, Gyroskope und Rotationsvektoren. Sensoren.

  • Umgebungssensoren

    Diese Sensoren messen verschiedene Umgebungsparameter wie die Temperatur und den Druck der Umgebungsluft, die Beleuchtung und die Luftfeuchtigkeit. Diese Kategorie umfasst Barometer, Fotometer und mit Thermometern.

  • Positionssensoren

    Diese Sensoren messen die physische Position eines Geräts. Diese Kategorie umfasst Ausrichtungssensoren und Magnetometer.

Mit dem Android-Sensor-Framework können Sie auf die auf dem Gerät verfügbaren Sensoren zugreifen und Rohdaten erfassen. Das Sensor-Framework bietet mehrere Klassen und Schnittstellen, mit denen Sie eine Vielzahl von sensorbezogenen Aufgaben ausführen können. Mit dem Sensor-Framework können Sie beispielsweise Folgendes tun:

  • Herausfinden, welche Sensoren auf einem Gerät verfügbar sind
  • Sie können die Funktionen eines einzelnen Sensors ermitteln, z. B. seinen maximalen Bereich, den Hersteller, die Leistungsanforderungen und die Auflösung.
  • Erfassen Sie Sensorrohdaten und definieren Sie die Mindestrate, mit der Sie Sensordaten erfassen.
  • Registrieren und unregisteren Sie Sensorereignis-Listener, die Sensoränderungen überwachen.

In diesem Artikel erhalten Sie einen Überblick über die Sensoren, die auf der Android-Plattform verfügbar sind. Sie bietet auch eine Einführung in das Sensorsystem.

Einführung in Sensoren

Über das Android-Sensor-Framework können Sie auf viele Arten von Sensoren zugreifen. Einige dieser Sensoren sind hardwarebasiert, andere softwarebasiert. Hardwarebasierte Sensoren sind physische Komponenten, die in ein Smartphone oder Tablet eingebaut sind. Die Daten werden durch direkte Messung bestimmter Umwelteigenschaften wie Beschleunigung, Stärke des geomagnetischen Feldes oder Winkeländerung abgeleitet. Softwarebasierte Sensoren sind keine physischen Geräte, obwohl sie hardwarebasierte Sensoren nachahmen. Softwarebasierte Sensoren leiten ihre Daten von einem oder mehreren der hardwarebasierten Sensoren ab und werden manchmal als virtuelle Sensoren oder synthetische Sensoren bezeichnet. Der lineare Beschleunigungssensor und der Schwerkraftsensor sind Beispiele für softwarebasierte Sensoren. In Tabelle 1 sind die von Android unterstützten Sensoren aufgeführt. Plattform.

Nur wenige Android-Geräte haben alle Arten von Sensoren. So haben beispielsweise die meisten Smartphones und Tablets einen Beschleunigungsmesser und ein Magnetometer, aber weniger Geräte haben Barometer oder Thermometer. Außerdem kann ein Gerät mehrere Sensoren eines bestimmten Typs haben. Ein Gerät kann beispielsweise zwei Gravitationssensoren mit unterschiedlicher Reichweite haben.

Tabelle 1 Von der Android-Plattform unterstützte Sensortypen.

Sensor Eingeben Beschreibung Übliche Anwendungsbereiche
TYPE_ACCELEROMETER Hardware Misst die Beschleunigungskraft in m/s2, die auf ein Gerät angewendet wird. alle drei physischen Achsen (x, y und z), einschließlich der Schwerkraft. Bewegungserkennung (Schütteln, Neigen usw.)
TYPE_AMBIENT_TEMPERATURE Hardware Misst die Raumtemperatur in Grad Celsius (°C). Weitere Informationen finden Sie im Hinweis unten. Überwachung der Lufttemperaturen.
TYPE_GRAVITY Software oder Hardware Gibt die Schwerkraft in m/s2 an, die auf ein Gerät angewendet wird drei physische Achsen (x, y, z). Bewegungserkennung (Schütteln, Neigen usw.)
TYPE_GYROSCOPE Hardware Misst die Drehgeschwindigkeit eines Geräts in Rad/s um jedes der drei Geräte Physische Achsen (x, y und z). Drehung erkennen (Drehen, Wenden usw.)
TYPE_LIGHT Hardware Misst die Beleuchtungsstärke in Lux. Bildschirmhelligkeit steuern
TYPE_LINEAR_ACCELERATION Software oder Hardware Misst die Beschleunigungskraft in m/s2, die sich ergibt. auf ein Gerät angewendet auf alle drei physischen Achsen (x, y und z) ohne die Schwerkraft. Beschleunigung entlang einer einzelnen Achse überwachen
TYPE_MAGNETIC_FIELD Hardware Misst das geomagnetische Umgebungsfeld für alle drei physischen Achsen (x, y, z) in μT. Einen Kompass erstellen
TYPE_ORIENTATION Software Misst die Drehung eines Geräts um alle drei physischen Achsen (x, y, z). Ab API-Level 3 können Sie die Neigungs- und Rotationsmatrix für Gerät mithilfe des Schwerkraftsensors und des Sensors für geomagnetische Felder in Verbindung mit getRotationMatrix() . Geräteposition ermitteln
TYPE_PRESSURE Hardware Misst den Umgebungsluftdruck in hPa oder mbar. Überwachung von Luftdruckänderungen.
TYPE_PROXIMITY Hardware Misst die Nähe eines Objekts in cm relativ zur Ansicht eines Objekts . Dieser Sensor wird in der Regel verwendet, um zu bestimmen, ob ein Mobiltelefon nicht ins Ohr gesprochen. Position des Telefons während eines Anrufs.
TYPE_RELATIVE_HUMIDITY Hardware Gibt die relative Luftfeuchtigkeit in Prozent (%) an. Taupunkt, absolute und relative Luftfeuchtigkeit überwachen
TYPE_ROTATION_VECTOR Software oder Hardware Misst die Ausrichtung eines Geräts anhand der drei Elemente des Rotationsvektor. Bewegungs- und Dreherkennung
TYPE_TEMPERATURE Hardware Misst die Temperatur des Geräts in Grad Celsius (°C). Dieser Sensor Implementierung variiert je nach Gerät und dieser Sensor wurde durch den Sensor TYPE_AMBIENT_TEMPERATURE ersetzt in API-Level 14 Temperaturüberwachung

Sensorrahmen

Sie können über das Android-Sensor-Framework auf diese Sensoren zugreifen und Rohdaten erfassen. Das Sensor-Framework ist Teil des android.hardware-Pakets und umfasst Folgendes Klassen und Benutzeroberflächen:

SensorManager
Mit dieser Klasse können Sie eine Instanz des Sensordienstes erstellen. Dieser Kurs bietet Verschiedene Methoden für den Zugriff auf und das Auflisten von Sensoren, das Registrieren und Aufheben der Registrierung von Sensorereignissen und Ausrichtungsinformationen abruft. Diese Klasse bietet auch mehrere Sensorkonstanten Sie werden verwendet, um die Sensorgenauigkeit zu melden, die Datenaufnahmeraten festzulegen und Sensoren zu kalibrieren.
Sensor
Mit dieser Klasse können Sie eine Instanz eines bestimmten Sensors erstellen. Diese Klasse bietet verschiedene Methoden, mit denen Sie die Funktionen eines Sensors ermitteln können.
SensorEvent
Das System verwendet diese Klasse, um ein Sensorereignisobjekt zu erstellen, das Informationen zu einem Sensorereignis an. Ein Sensorereignisobjekt enthält die folgenden Informationen: die Sensorrohdaten, den Sensortyp, der das Ereignis generiert hat, die Genauigkeit der Daten und den Zeitstempel für .
SensorEventListener
Mit dieser Schnittstelle können Sie zwei Rückrufmethoden erstellen, die Benachrichtigungen (Sensorereignisse) erhalten, wenn sich die Sensorwerte oder die Sensorgenauigkeit ändern.

In einer typischen Anwendung verwenden Sie diese sensorbezogenen APIs, um zwei grundlegende Aufgaben auszuführen:

  • Sensoren und Sensorfunktionen erkennen

    Die Identifizierung von Sensoren und Sensorfunktionen während der Laufzeit ist nützlich, Funktionen, die bestimmte Sensortypen oder -funktionen nutzen. Vielleicht möchten Sie alle Sensoren eines Geräts ermitteln und Anwendungsfunktionen deaktivieren die auf nicht vorhandene Sensoren angewiesen sind. Ebenso können Sie alle Sensoren eines bestimmten Typs identifizieren, um die Sensorimplementierung mit der optimalen Leistung für Ihre Anwendung auszuwählen.

  • Sensorereignisse überwachen

    Durch das Überwachen von Sensorereignissen können Sie Rohsensordaten erfassen. Jedes Mal, wenn ein Sensorereignis ein Sensor eine Änderung der gemessenen Parameter erkennt. Bei einem Sensorereignis erhalten Sie mit vier Informationen: dem Namen des Sensors, der das Ereignis ausgelöst hat, dem Zeitstempel des Ereignisses, die Genauigkeit des Ereignisses und die Sensorrohdaten, die ausgelöst haben über den Termin.

Sensorverfügbarkeit

Die Verfügbarkeit des Sensors kann von Gerät zu Gerät und von Android-Version zu Android-Version variieren. Das liegt daran, dass die Android-Sensoren im Laufe mehrerer Plattform-Releases. Beispielsweise wurden in Android 1.5 (API-Level 3) viele Sensoren eingeführt, aber einige wurden nicht implementiert und standen erst ab Android 2.3 (API-Level 9) zur Verfügung. Ebenso wurden in Android 2.3 (API-Level 9) und Android 4.0 (API-Level 14) mehrere Sensoren eingeführt. Zwei Sensoren wurden eingestellt und durch neuere, bessere Sensoren ersetzt.

In Tabelle 2 ist die Verfügbarkeit der einzelnen Sensoren für jede Plattform zusammengefasst. Nur vier da die Sensoren auf diesen Plattformen durchgeführt wurden. Sensoren, die die als veraltet aufgeführt sind, weiterhin auf nachfolgenden Plattformen verfügbar sind (vorausgesetzt, die Sensor auf einem Gerät vorhanden ist), was der Richtlinie zur Aufwärtskompatibilität von Android entspricht.

Tabelle 2: Sensorverfügbarkeit nach Plattform.

Sensor Android 4.0
(API-Level 14)		 Android 2.3
(API-Level 9)		 Android 2.2
(API-Level 8)		 Android 1.5 
(API-Level 3)
TYPE_ACCELEROMETER Ja Ja Ja Ja
TYPE_AMBIENT_TEMPERATURE Ja – – –
TYPE_GRAVITY Ja Ja – –
TYPE_GYROSCOPE Ja Ja –1 –1
TYPE_LIGHT Ja Ja Ja Ja
TYPE_LINEAR_ACCELERATION Ja Ja – –
TYPE_MAGNETIC_FIELD Ja Ja Ja Ja
TYPE_ORIENTATION Ja2 Ja2 Ja2 Ja
TYPE_PRESSURE Ja Ja –1 –1
TYPE_PROXIMITY Ja Ja Ja Ja
TYPE_RELATIVE_HUMIDITY Ja – – –
TYPE_ROTATION_VECTOR Ja Ja – –
TYPE_TEMPERATURE Ja2 Ja Ja Ja

1 Dieser Sensortyp wurde in Android 1.5 (API-Level 3) hinzugefügt, konnte aber erst ab Android 2.3 (API-Level 9) verwendet werden.

2 Dieser Sensor ist verfügbar, eingestellt.

Sensoren und Sensorfunktionen identifizieren

Das Android-Sensor-Framework bietet mehrere Methoden, mit denen Sie zur Laufzeit ganz einfach ermitteln können, welche Sensoren sich auf einem Gerät befinden. Die API bietet auch Methoden, mit denen Sie die Funktionen jedes Sensors, wie etwa maximale Reichweite, Auflösung und Leistung Anforderungen.

Um die Sensoren auf einem Gerät zu identifizieren, müssen Sie zuerst eine Referenz zum Sensordienst abrufen. Dazu erstellen Sie eine Instanz der Klasse SensorManager, indem Sie die Methode getSystemService() aufrufen und das Argument SENSOR_SERVICE übergeben. Beispiel:

KotlinJava
private lateinit var sensorManager: SensorManager
...
sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager
 
private SensorManager sensorManager;
...
sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);

Als Nächstes können Sie eine Liste aller Sensoren auf einem Gerät abrufen, indem Sie die Methode getSensorList() mit der Konstante TYPE_ALL aufrufen. Beispiel:

KotlinJava
val deviceSensors: List<Sensor> = sensorManager.getSensorList(Sensor.TYPE_ALL)
 
List<Sensor> deviceSensors = sensorManager.getSensorList(Sensor.TYPE_ALL);

Wenn Sie alle Sensoren eines bestimmten Typs auflisten möchten, können Sie statt TYPE_ALL wie TYPE_GYROSCOPE, TYPE_LINEAR_ACCELERATION oder TYPE_GRAVITY.

Sie können auch mithilfe der Methode getDefaultSensor() und der Typkonstante für einen bestimmten Sensor feststellen, ob ein bestimmter Sensortyp auf einem Gerät vorhanden ist. Wenn ein Gerät mehr als einen Sensor eines bestimmten Typs hat, wird einer der müssen als Standardsensoren festgelegt werden. Wenn für einen bestimmten Sensor kein Standardsensor vorhanden ist, Sensortyp verwendet, gibt der Methodenaufruf null zurück, was bedeutet, dass das Gerät diesen Typ Sensor. Der folgende Code prüft beispielsweise, ob sich ein Magnetometer an einem Gerät befindet:

KotlinJava
private lateinit var sensorManager: SensorManager
...
sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager
if (sensorManager.getDefaultSensor(Sensor.TYPE_MAGNETIC_FIELD) != null) {
    // Success! There's a magnetometer.
} else {
    // Failure! No magnetometer.
}
 
private SensorManager sensorManager;
...
sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
if (sensorManager.getDefaultSensor(Sensor.TYPE_MAGNETIC_FIELD) != null){
    // Success! There's a magnetometer.
} else {
    // Failure! No magnetometer.
}

Hinweis: Android-Gerätehersteller sind nicht verpflichtet, bestimmte Sensortypen in ihre Android-Geräte einzubauen. Daher können Geräte eine Vielzahl von Sensorkonfigurationen haben.

Sie können nicht nur die Sensoren auf einem Gerät auflisten, sondern auch mithilfe der öffentlichen Methoden der Klasse Sensor die Funktionen und Attribute einzelner Sensoren ermitteln. Das ist nützlich, wenn sich Ihre Anwendung je nach Sensoren oder Sensorfunktionen auf einem Gerät unterschiedlich verhalten soll. Sie können beispielsweise getResolution() und getMaximumRange() verwenden. um die Auflösung und den maximalen Messbereich eines Sensors zu ermitteln. Sie können auch die Methode getPower() verwenden, um die Leistungsanforderungen eines Sensors abzurufen.

Zwei der öffentlichen Methoden sind besonders nützlich, wenn Sie Ihre Anwendung für Sensoren verschiedener Hersteller oder Versionen eines Sensors. Wenn Ihre App zum Beispiel Nutzergesten wie Neigen und Schütteln überwachen muss, könnten Sie und Optimierungen für neuere Geräte, die einen speziellen Anbieter mit einem Gravitationssensor und einem anderen Regeln und Optimierungen für Geräte ohne Gravitationssensor und nur einen Beschleunigungsmesser. Das folgende Codebeispiel zeigt, wie Sie dazu die Methoden getVendor() und getVersion() verwenden. In diesem Beispiel suchen wir nach einem Schwerkraftsensor, der Google LLC als Anbieter angibt. die Versionsnummer 3 hat. Ist dieser Sensor nicht auf dem Gerät vorhanden, versuchen wir, den Beschleunigungsmesser.

KotlinJava
private lateinit var sensorManager: SensorManager
private var mSensor: Sensor? = null

...

sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager

if (sensorManager.getDefaultSensor(Sensor.TYPE_GRAVITY) != null) {
    val gravSensors: List<Sensor> = sensorManager.getSensorList(Sensor.TYPE_GRAVITY)
    // Use the version 3 gravity sensor.
    mSensor = gravSensors.firstOrNull { it.vendor.contains("Google LLC") && it.version == 3 }
}
if (mSensor == null) {
    // Use the accelerometer.
    mSensor = if (sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER) != null) {
        sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER)
    } else {
        // Sorry, there are no accelerometers on your device.
        // You can't play this game.
        null
    }
}
 
private SensorManager sensorManager;
private Sensor mSensor;

...

sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
mSensor = null;

if (sensorManager.getDefaultSensor(Sensor.TYPE_GRAVITY) != null){
    List<Sensor> gravSensors = sensorManager.getSensorList(Sensor.TYPE_GRAVITY);
    for(int i=0; i<gravSensors.size(); i++) {
        if ((gravSensors.get(i).getVendor().contains("Google LLC")) &&
           (gravSensors.get(i).getVersion() == 3)){
            // Use the version 3 gravity sensor.
            mSensor = gravSensors.get(i);
        }
    }
}
if (mSensor == null){
    // Use the accelerometer.
    if (sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER) != null){
        mSensor = sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);
    } else{
        // Sorry, there are no accelerometers on your device.
        // You can't play this game.
    }
}

Eine weitere nützliche Methode ist die getMinDelay()-Methode, mit der das minimale Zeitintervall (in Mikrosekunden) zurückgegeben wird, das ein Sensor zum Erfassen von Daten verwenden kann. Beliebiger Sensor gibt einen Wert ungleich null für getMinDelay() zurück. ist eine Streaming-Methode Sensor. Streamingsensoren erfassen Daten in regelmäßigen Abständen und wurden in Android 2.3 (API-Level 9) eingeführt. Wenn ein Sensor beim Aufrufen der getMinDelay()-Methode Null zurückgibt, bedeutet dies, dass ist kein Streamingsensor, da er Daten nur dann ausgibt, wenn sich der Parameter, die er erkennt.

Die Methode getMinDelay() ist nützlich, da Sie damit die maximale Rate ermitteln können, mit der ein Sensor Daten erfassen kann. Wenn bestimmte Funktionen in Ihrer Anwendung ein hohes Datenvolumen erfordern oder Streaming-Sensoren nutzen, können Sie mit dieser Methode bestimmen, die diese Anforderungen erfüllt, und aktivieren oder deaktivieren Sie dann die entsprechenden Funktionen in Ihrer App. entsprechend anpassen.

Achtung:Die maximale Datenaufnahmerate eines Sensors ist nicht die Geschwindigkeit, mit der das Sensor-Framework Sensordaten an Ihre Anwendung liefert. Das Sensor-Framework meldet Daten über Sensorereignisse. Die Häufigkeit, mit der Ihre Anwendung Sensorereignisse empfängt, hängt von mehreren Faktoren ab. Weitere Informationen finden Sie unter Sensorereignisse überwachen.

Sensorereignisse überwachen

Wenn Sie Rohsensordaten überwachen möchten, müssen Sie zwei Rückrufmethoden implementieren, die über die SensorEventListener-Schnittstelle verfügbar sind: onAccuracyChanged() und onSensorChanged(). Das Android-System ruft diese Methoden auf, wenn Folgendes eintritt:

Im folgenden Code wird gezeigt, wie Sie mit der Methode onSensorChanged() Daten vom Lichtsensor überwachen. In diesem Beispiel werden die Sensor-Rohdaten in einem TextView angezeigt. das entspricht in der Datei „main.xml“ als sensor_data definiert.

KotlinJava
class SensorActivity : Activity(), SensorEventListener {
    private lateinit var sensorManager: SensorManager
    private var mLight: Sensor? = null

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

        sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager
        mLight = sensorManager.getDefaultSensor(Sensor.TYPE_LIGHT)
    }

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

    override fun onSensorChanged(event: SensorEvent) {
        // The light sensor returns a single value.
        // Many sensors return 3 values, one for each axis.
        val lux = event.values[0]
        // Do something with this sensor value.
    }

    override fun onResume() {
        super.onResume()
        mLight?.also { light ->
            sensorManager.registerListener(this, light, SensorManager.SENSOR_DELAY_NORMAL)
        }
    }

    override fun onPause() {
        super.onPause()
        sensorManager.unregisterListener(this)
    }
}
 
public class SensorActivity extends Activity implements SensorEventListener {
    private SensorManager sensorManager;
    private Sensor mLight;

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

        sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
        mLight = sensorManager.getDefaultSensor(Sensor.TYPE_LIGHT);
    }

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

    @Override
    public final void onSensorChanged(SensorEvent event) {
        // The light sensor returns a single value.
        // Many sensors return 3 values, one for each axis.
        float lux = event.values[0];
        // Do something with this sensor value.
    }

    @Override
    protected void onResume() {
        super.onResume();
        sensorManager.registerListener(this, mLight, SensorManager.SENSOR_DELAY_NORMAL);
    }

    @Override
    protected void onPause() {
        super.onPause();
        sensorManager.unregisterListener(this);
    }
}

In diesem Beispiel wird die Standarddatenverzögerung (SENSOR_DELAY_NORMAL) angegeben, wenn die Methode registerListener() aufgerufen wird. Die Daten Verzögerung (oder Abtastrate) steuert das Intervall, in dem Sensorereignisse an Ihre Anwendung gesendet werden mithilfe der Callback-Methode onSensorChanged(). Die Standarddatenverzögerung eignet sich für das Überwachen typischer Änderungen der Bildschirmausrichtung und verwendet eine Verzögerung von 200.000 Mikrosekunden. Sie können auch andere Datenverzögerungen angeben, z. B. SENSOR_DELAY_GAME (20.000 Mikrosekunden), SENSOR_DELAY_UI (60.000 Mikrosekunden) oder SENSOR_DELAY_FASTEST (0 Mikrosekunden). Ab Android 3.0 (API Ebene 11) können Sie die Verzögerung auch als absoluten Wert (in Mikrosekunden) angeben.

Die angegebene Verzögerung ist nur eine vorgeschlagene Verzögerung. Das Android-System und andere Apps können Sie diese Verzögerung ändern. Es wird empfohlen, die maximale Verzögerung anzugeben, da das System in der Regel eine kürzere Verzögerung verwendet als die von Ihnen angegebene. Sie sollten also die niedrigste Abtastrate auswählen, die die Anforderungen Ihrer Anwendung erfüllt. Eine größere Verzögerung führt zu Der Prozessor wird weniger belastet und verbraucht so weniger Energie.

Es gibt keine öffentliche Methode zum Bestimmen der Geschwindigkeit, mit der das Sensor-Framework sendet Sensorereignisse an Ihre Anwendung senden; Sie können jedoch die Zeitstempel verwenden, Sensorereignis verwenden, um die Abtastrate für mehrere Ereignisse zu berechnen. Sie sollten die Einstellung der Stichprobenrate (Verzögerung), nachdem Sie sie festgelegt haben. Falls Sie die Verzögerung ändern müssen, muss die Registrierung des Sensor-Listeners aufheben und dann erneut registrieren.

Wichtig: In diesem Beispiel werden die onResume() und onPause()-Callback-Methoden zum Registrieren und Aufheben der Registrierung des Sensorereignisses Listener. Es hat sich bewährt, Sensoren, die Sie nicht benötigen, immer zu deaktivieren, insbesondere wenn Ihre Aktivität pausiert. Wenn Sie dies nicht tun, kann sich der Akku innerhalb weniger Stunden entladen, da einige Sensoren haben hohe Anforderungen an die Stromversorgung und verbrauchen möglicherweise schnell die Akkukapazität. Das System deaktiviert die Sensoren nicht automatisch, wenn das Display ausgeschaltet wird.

Umgang mit verschiedenen Sensorkonfigurationen

Android spezifiziert keine standardmäßige Sensorkonfiguration für Geräte, Gerätehersteller können also jede gewünschte Sensorkonfiguration in ihre Android-Mobilgeräte Daher können Geräte verschiedene mit unterschiedlichen Konfigurationen. Wenn Ihre Anwendung einen bestimmten Sensortyp benötigt, müssen Sie dafür sorgen, Sensor ist auf einem Gerät vorhanden, sodass deine App erfolgreich ausgeführt werden kann.

Sie haben zwei Möglichkeiten, um sicherzustellen, dass ein bestimmter Sensor auf einem Gerät vorhanden ist:

  • Erkennt Sensoren während der Laufzeit und aktivieren oder deaktivieren Sie Anwendungsfunktionen nach Bedarf.
  • Verwenden Sie Google Play-Filter, um eine Ausrichtung auf Geräte mit bestimmten Sensorkonfigurationen vorzunehmen.

Jede Option wird in den folgenden Abschnitten erläutert.

Sensoren zur Laufzeit erkennen

Wenn Ihre Anwendung einen bestimmten Sensortyp verwendet, aber nicht darauf angewiesen ist, können Sie mit dem Sensor-Framework den Sensor zur Laufzeit erkennen und dann die Anwendungsfunktionen entsprechend deaktivieren oder aktivieren. Eine Navigations-App kann beispielsweise den Temperatursensor, den Drucksensor, den GPS-Sensor und den Sensor für das geomagnetische Feld verwenden, um die Temperatur, den barometrischen Druck, den Standort und die Kompasspeilung anzuzeigen. Hat ein Gerät keinen Drucksensor, kannst du den um das Fehlen des Drucksensors während der Laufzeit zu erkennen und den Teil der Benutzeroberfläche Ihrer Anwendung, der die Auslastung anzeigt. Der folgende Code prüft beispielsweise ob es einen Drucksensor am Gerät gibt:

KotlinJava
private lateinit var sensorManager: SensorManager
...
sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager

if (sensorManager.getDefaultSensor(Sensor.TYPE_PRESSURE) != null) {
    // Success! There's a pressure sensor.
} else {
    // Failure! No pressure sensor.
}
 
private SensorManager sensorManager;
...
sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
if (sensorManager.getDefaultSensor(Sensor.TYPE_PRESSURE) != null){
    // Success! There's a pressure sensor.
} else {
    // Failure! No pressure sensor.
}

Google Play-Filter für die Ausrichtung auf bestimmte Sensorkonfigurationen verwenden

Wenn Sie Ihre App bei Google Play veröffentlichen, können Sie mit dem Element <uses-feature> in Ihrer Manifestdatei Ihre App von Geräten herausfiltern, die nicht die richtige Sensorkonfiguration für Ihre App haben. Das Element <uses-feature> hat mehrere Hardware-Beschreibungen, mit denen Sie Anwendungen basierend auf der Anwesenheit bestimmter Sensoren filtern können. Sie können unter anderem folgende Sensoren auflisten: Beschleunigungsmesser, Barometer, Kompass (geomagnetisches Feld), Gyroskop, Licht und Näherung Die Hier sehen Sie ein Beispiel für einen Manifesteintrag, mit dem Apps gefiltert werden, die keinen Beschleunigungsmesser haben:

<uses-feature android:name="android.hardware.sensor.accelerometer"
              android:required="true" />

Wenn Sie dieses Element und diesen Descriptor dem Manifest Ihrer App hinzufügen, sehen Nutzer Ihre App bei Google Play nur, wenn ihr Gerät einen Beschleunigungsmesser hat.

Sie sollten den Deskriptor nur dann auf android:required="true" festlegen, wenn Ihre Anwendung ausschließlich auf einem bestimmten Sensor basiert. Wenn Ihre Anwendung für einige Funktionen einen Sensor verwendet, läuft auch ohne den Sensor, sollten Sie ihn im <uses-feature> auflisten -Element, legen Sie jedoch den Deskriptor auf android:required="false" fest. So wird sichergestellt, Geräte können deine App auch dann installieren, wenn sie diesen Sensor nicht haben. Dies ist auch ein Best Practice für das Projektmanagement, die Ihnen hilft, den Überblick über die von Ihrer Anwendung verwendeten Funktionen zu behalten. Wenn Ihre Anwendung einen bestimmten Sensor verwendet, aber ohne den Sensor läuft, sollten Sie den Sensor zur Laufzeit erkennen und die Anwendungsfunktionen angemessen sein.

Koordinatensystem mit Sensor

Im Allgemeinen verwendet das Sensor-Framework ein standardmäßiges 3-Achsen-Koordinatensystem, um Datenwerte auszudrücken. Bei den meisten Sensoren wird das Koordinatensystem relativ zum Display des Geräts definiert, wenn es in der Standardausrichtung gehalten wird (siehe Abbildung 1). Wenn ein Gerät in der Standardausrichtung gehalten wird, ist die X-Achse horizontal und zeigt nach rechts, die Y-Achse ist vertikal und zeigt nach oben und die Z-Achse zeigt zur Außenseite des Displays. In diesem System haben Koordinaten hinter dem Bildschirm negative Z-Werte. Dieses Koordinatensystem wird von den folgenden Sensoren verwendet:

Abbildung 1: Koordinatensystem (relativ zu einem Gerät), das vom Sensor verwendet wird der API erstellen.

Der wichtigste Punkt bei diesem Koordinatensystem ist, dass die Achsen wird vertauscht, wenn sich die Bildschirmausrichtung des Geräts ändert, also das Koordinatensystem des Sensors. ändert sich nie, wenn sich das Gerät bewegt. Dieses Verhalten entspricht dem des OpenGL-Koordinatensystems.

Sie sollten außerdem verstehen, dass Ihre Anwendung nicht davon ausgehen darf, dass ein natürliches Gerät (Standard) ist Hochformat. Die natürliche Ausrichtung vieler Tablets ist das Querformat. Und basiert das Sensorkoordinatensystem immer auf der natürlichen Ausrichtung des Geräts.

Wenn Ihre Anwendung schließlich Sensordaten mit dem Bildschirm auf dem Bildschirm abgleicht, müssen Sie die Funktion getRotation()-Methode zur Bestimmung der Bildschirmdrehung und verwende dann die Methode remapCoordinateSystem()-Zuordnungsmethode Sensorkoordinaten in Bildschirmkoordinaten ein. Das müssen Sie auch dann tun, wenn in Ihrem Manifest angegeben ist, im Hochformat.

Hinweis: Einige Sensoren und Methoden verwenden ein Koordinatensystem, das sich auf den Weltkoordinatenbezug bezieht (im Gegensatz zum Gerätekoordinatenbezug). Diese Sensoren und Methoden geben Daten zurück, die die Gerätebewegung oder die Geräteposition relativ zum Erde. Weitere Informationen findest du unter der Methode getOrientation(), der Methode getRotationMatrix(), Ausrichtung Sensor und Rotationsvektor Sensor

Ratenbegrenzung des Sensors

Zum Schutz potenziell vertraulicher Daten von Nutzern wird die Aktualisierungsrate von Daten bestimmter Bewegungs- und Positionssensoren vom System begrenzt, wenn Ihre App auf Android 12 (API-Level 31) oder höher ausgerichtet ist. Diese Daten die Werte enthält, die vom Beschleunigungsmesser Gyroskop und Geomagnetisches Feld

Die Beschränkung der Aktualisierungsrate hängt davon ab, wie Sie auf Sensordaten zugreifen:

Wenn Ihre App Bewegungssensordaten mit einer höheren Geschwindigkeit erfassen muss, müssen Sie deklarieren: HIGH_SAMPLING_RATE_SENSORS wie im folgenden Code-Snippet dargestellt. Andernfalls, wenn Ihre App versucht, Bewegungssensordaten mit einer höheren Rate zu erheben, ohne diese Berechtigung zu deklarieren, tritt eine SecurityException auf.

AndroidManifest.xml

<manifest ...>
    <uses-permission android:name="android.permission.HIGH_SAMPLING_RATE_SENSORS"/>
    <application ...>
        ...
    </application>
</manifest>

Best Practices für den Zugriff auf und die Verwendung von Sensoren

Beachten Sie bei der Sensorimplementierung die in diesem Abschnitt beschriebenen Richtlinien. Diese Richtlinien sind Best Practices für alle, die das Sensor-Framework verwenden, um auf Sensoren zuzugreifen und Sensordaten zu erfassen.

Nur Sensordaten im Vordergrund erheben

Auf Geräten mit Android 9 (API-Level 28) oder höher werden Apps, die in der Hintergrund gelten die folgenden Einschränkungen:

  • Für Sensoren, die den kontinuierlichen Berichtsmodus verwenden, z. B. Beschleunigungsmesser und Gyroskope, werden keine Ereignisse empfangen.
  • Sensoren, die den bei Änderung oder One-Shot keine Ereignisse empfangen.

Angesichts dieser Einschränkungen ist es am besten, Sensorereignisse zu erkennen, wenn Ihre im Vordergrund ausgeführt wird oder Teil eines Dienst im Vordergrund.

Sensor-Listener abmelden

Deregistrieren Sie den Listener eines Sensors, wenn Sie ihn nicht mehr verwenden oder die Sensoraktivität pausiert. Wenn ein Sensor-Listener registriert und seine Aktivität pausiert wird, um weiterhin Daten zu erfassen und Akkuressourcen zu nutzen, bis Sie die Registrierung des Sensors aufheben. Die folgenden Der Code zeigt, wie Sie mit der Methode onPause() die Registrierung eines Listeners aufheben:

KotlinJava
private lateinit var sensorManager: SensorManager
...
override fun onPause() {
    super.onPause()
    sensorManager.unregisterListener(this)
}
 
private SensorManager sensorManager;
...
@Override
protected void onPause() {
    super.onPause();
    sensorManager.unregisterListener(this);
}

Weitere Informationen findest du unter unregisterListener(SensorEventListener).

Mit dem Android-Emulator testen

Der Android-Emulator enthält eine Reihe virtueller Sensorsteuerelemente, um Sensoren wie Beschleunigungsmesser, Umgebungstemperatur, Magnetometer, Näherung, Licht und mehr.

Der Emulator verwendet eine Verbindung mit einem Android-Gerät, auf dem der SdkControllerSensor Diese App ist nur für Geräte mit Android 4.0 (API) verfügbar. Level 14) oder höher. Wenn auf dem Gerät Android 4.0 installiert ist, muss Revision 2 installiert sein. Die App SdkControllerSensor überwacht Änderungen in des Geräts und sendet sie an den Emulator. Der Emulator wird dann anhand der neuen Werte transformiert, die er von den Sensoren auf Ihrem Gerät empfängt.

Sie können den Quellcode für die App SdkControllerSensor in der folgende Position:

$ your-android-sdk-directory/tools/apps/SdkController

So übertragen Sie Daten zwischen Ihrem Gerät und dem Emulator:

  1. Prüfen Sie, ob USB-Kabel auf Ihrem Gerät aktiviert ist.
  2. Verbinden Sie Ihr Gerät über ein USB-Kabel mit dem Entwicklungscomputer.
  3. Starten Sie die App SdkControllerSensor auf Ihrem Gerät.
  4. Wählen Sie in der App die Sensoren aus, die Sie emulieren möchten.

  5. Führen Sie den folgenden adb-Befehl aus:

    6. $ adb forward tcp:1968 tcp:1968
  6. Starten Sie den Emulator. Sie sollten jetzt Transformationen auf den Emulator anwenden können, indem Sie Ihr Gerät bewegen.

Hinweis : Wenn die Bewegungen, Gerät den Emulator nicht transformiert, führen Sie den Befehl adb-Befehl noch einmal aus Schritt 5.

Weitere Informationen finden Sie in der Android-Dokumentation Emulator-Leitfaden.

onSensorChanged()-Methode nicht blockieren

Sensordaten können sich sehr schnell ändern. Das bedeutet, dass das System die Methode onSensorChanged(SensorEvent) möglicherweise recht oft aufruft. Es empfiehlt sich, in der onSensorChanged(SensorEvent)-Methode möglichst wenig zu tun, damit sie nicht blockiert wird. Wenn für Ihre Anwendung eine Datenfilterung oder eine Reduzierung von Sensordaten erforderlich ist, sollten Sie diese Arbeit außerhalb der Methode onSensorChanged(SensorEvent) ausführen.

Nicht mehr unterstützte Methoden oder Sensortypen verwenden

Mehrere Methoden und Konstanten wurden eingestellt. Insbesondere die TYPE_ORIENTATION Sensortyp wurde eingestellt. Verwenden Sie stattdessen die Methode getOrientation(), um Daten zur Ausrichtung abzurufen. Der Sensortyp TYPE_TEMPERATURE wird ebenfalls nicht mehr unterstützt. Sie sollten auf Geräten stattdessen den Sensortyp „TYPE_AMBIENT_TEMPERATURE“ auf denen Android 4.0 ausgeführt wird.

Sensoren vor der Verwendung prüfen

Prüfen Sie immer, ob ein Sensor auf einem Gerät vorhanden ist, bevor Sie versuchen, Daten von ihm zu erfassen. Angenommen Sie nicht, dass ein Sensor vorhanden ist, nur weil er häufig verwendet wird. Gerätehersteller sind keine bestimmten Sensoren in ihren Geräten bereitstellen müssen.

Sensorverzögerungen sorgfältig auswählen

Wenn Sie einen Sensor mit der Methode registerListener() registrieren, wählen Sie eine Übermittlungsrate aus, die für Ihre Anwendung oder Ihren Anwendungsfall geeignet ist. Sensoren können Daten mit sehr hohen Raten liefern. Wenn Sie dem System erlauben, zusätzliche Daten, die Sie nicht benötigen, verschwenden Systemressourcen und verbrauchen Akkuleistung.

Weiter
Bewegungssensoren