Sensoren – Übersicht

Die meisten Android-Geräte verfügen über integrierte Sensoren, die Bewegung, Ausrichtung, und verschiedenen Umweltbedingungen. 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 Wetteranwendung den Temperatur- und Luftfeuchtigkeitssensor des Geräts, um den Taupunkt oder die Fahrtdauer zu berechnen und zu melden. mithilfe des Sensors für geomagnetische Felder und des Beschleunigungsmessers einen Kompass melden. die Lagerung.

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

• Bewegungssensoren

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

• Umgebungssensoren

  Diese Sensoren messen verschiedene Umgebungsparameter, wie z. B. die Umgebungstemperatur Druck, Beleuchtung und 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.

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

• Herausfinden, welche Sensoren auf einem Gerät verfügbar sind
• Die Funktionen eines einzelnen Sensors bestimmen, z. B. maximale Reichweite, Hersteller, Leistung und der Lösung vor.
• Erfassen Sie Sensorrohdaten und definieren Sie die Mindestrate, mit der Sie Sensordaten erfassen.
• Sensorereignis-Listener, die Sensoränderungen überwachen, registrieren und die Registrierung aufheben

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

Mit dem Android-Sensor-Framework kannst du auf viele Arten von Sensoren zugreifen. Einige dieser Sensoren sind hardwarebasiert und einige softwarebasiert. Hardwarebasierte Sensoren sind physische Komponenten, auf einem Mobiltelefon oder Tablet. Sie leiten ihre Daten ab, indem sie die spezifischen wie Beschleunigung, geomagnetische Feldstärke oder Winkeländerung. Softwarebasiert Sensoren sind keine physischen Geräte, obwohl sie hardwarebasierte Sensoren imitieren. Softwarebasierte Sensoren ihre Daten von einem oder mehreren hardwarebasierten Sensoren ableiten. oder synthetischen Sensoren nutzen. Der lineare Beschleunigungssensor und der Schwerkraftsensor sind Beispiele für softwarebasierten Sensoren. In Tabelle 1 sind die von Android unterstützten Sensoren aufgeführt. Plattform.

Nur wenige Android-Geräte haben alle Arten von Sensor. Die meisten Mobiltelefone und Tablets verfügen über einen Beschleunigungsmesser und ein Magnetometer, aber weniger Geräte haben Barometer oder Thermometern zu verwenden. Außerdem kann ein Gerät mehr als einen Sensor eines bestimmten Typs haben. Für Beispiel: Ein Gerät kann zwei Schwerkraftsensoren haben, die jeweils einen anderen Bereich haben.

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

Sensorrahmen

Mithilfe des Android-Sensor-Frameworks können Sie auf diese Sensoren zugreifen und Sensorrohdaten 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

Über diese Oberfläche lassen sich zwei Callback-Methoden erstellen, die Benachrichtigungen erhalten (Sensor -Ereignissen), wenn sich Sensorwerte ändern oder sich die Sensorgenauigkeit ändert.

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. Vielleicht möchten Sie auch alle Sensoren eines bestimmten Typs aus, damit Sie die Sensorimplementierung auswählen können, die die optimale Leistung bietet für Ihre Anwendung.

• Sensorereignisse beobachten

  Über das Monitoring von Sensorereignissen werden Sensorrohdaten erfasst. Jedes Mal, wenn ein Sensorereignis ein Sensor eine Änderung der zu messenden 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 Sensor-Rohdaten, die ausgelöst haben über den Termin.

Sensorverfügbarkeit

Die Sensorverfügbarkeit variiert je nach Gerät, kann aber auch je nach Android-Gerät variieren. Versionen. Das liegt daran, dass die Android-Sensoren 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. Gleichermaßen In Android 2.3 (API-Level 9) und Android 4.0 (API-Level 14) wurden mehrere Sensoren eingeführt. Zwei wurden eingestellt und durch neuere, bessere Sensoren ersetzt.

In Tabelle 2 ist die Verfügbarkeit der einzelnen Sensoren nach 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.

¹ Dieser Sensortyp wurde in Android 1.5 (API-Level) hinzugefügt 3), aber erst ab Android 2.3 (API-Level 9) verfügbar war.

² Dieser Sensor ist verfügbar, eingestellt.

Sensoren und Sensorfunktionen identifizieren

Das Sensor-Framework von Android bietet mehrere Methoden, mit denen Sie 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 eines Geräts zu identifizieren, musst du zuerst eine Referenz zum Sensor abrufen . Dazu erstellen Sie eine Instanz der SensorManager-Klasse, indem Sie getSystemService()-Methode aufrufen und im Argument SENSOR_SERVICE. Beispiel:

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() und die Konstante TYPE_ALL verwenden. Beispiel:

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.

Außerdem können Sie mithilfe der Methode getDefaultSensor() und Übergeben des Typs ermitteln, ob auf dem Gerät ein bestimmter Sensortyp vorhanden ist. für einen bestimmten Sensor konstant 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 nicht über diesen Sensor. Der folgende Code prüft beispielsweise, ob sich ein Magnetometer an einem Gerät befindet:

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:Unter Android müssen Gerätehersteller keine bestimmte Arten von Sensoren in ihre Android-Geräte einbauen. So können Geräte Sensorkonfigurationen.

Neben der Auflistung der Sensoren eines Geräts kannst du auch die öffentlichen Methoden des Sensor, um die Fähigkeiten und Attribute einzelner Sensoren. Dies ist nützlich, wenn Sie möchten, dass sich Ihre Anwendung je nachdem, welche Sensoren oder Sensorfunktionen sind auf einem Gerät verfügbar. 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 getPower()-Methode, um den Energiebedarf eines Sensors zu ermitteln.

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 Datenfilterungsregeln und -optimierungen für Geräte ohne Gravitationssensor und nur einen Beschleunigungsmesser. Das folgende Codebeispiel zeigt, wie Sie mit den Methoden getVendor() und getVersion() Folgendes tun können: dies. 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.

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 Methode getMinDelay(). gibt das minimale Zeitintervall (in Mikrosekunden) zurück, 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 mit Android 2.3 (API Level 9). 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, bestimmen Sie den maximalen Preis, an dem ein Sensor Daten erfassen kann. Wenn bestimmte Funktionen 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. Die Sensor-Framework meldet Daten anhand von Sensorereignissen. Verschiedene Faktoren beeinflussen die Geschwindigkeit, dass Ihre App Sensorereignisse empfängt. Weitere Informationen finden Sie unter Sensorereignisse überwachen.

Sensorereignisse überwachen

Um Sensor-Rohdaten zu überwachen, müssen Sie zwei Callback-Methoden implementieren, die über der SensorEventListener-Schnittstelle: onAccuracyChanged() und onSensorChanged(). Das Android-System ruft auf, diese Methoden immer dann, wenn Folgendes eintritt:

• Die Genauigkeit eines Sensors ändert sich.

  In diesem Fall ruft das System die Methode onAccuracyChanged() auf und gibt an, mit einem Verweis auf das Sensor-Objekt, das sich geändert hat, und des Sensors verbessert. Die Genauigkeit wird durch eine von vier Statuskonstanten angegeben: SENSOR_STATUS_ACCURACY_LOW, SENSOR_STATUS_ACCURACY_MEDIUM, SENSOR_STATUS_ACCURACY_HIGH, oder SENSOR_STATUS_UNRELIABLE.

• Ein Sensor meldet einen neuen Wert.

  In diesem Fall ruft das System die Methode onSensorChanged() auf und gibt Ein SensorEvent-Objekt. Ein SensorEvent-Objekt enthält Informationen zu den neuen Sensordaten, darunter die Genauigkeit der Daten, die Sensor, der die Daten generiert hat, den Zeitstempel, zu dem die Daten generiert wurden, und der neue die der Sensor aufgezeichnet hat.

Der folgende Code zeigt, wie Sie mit der Methode onSensorChanged() Daten aus folgenden Quellen überwachen: des Lichtsensors an. In diesem Beispiel werden die Sensor-Rohdaten in einem TextView angezeigt. das entspricht in der Datei „main.xml“ als sensor_data definiert.

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(). Standardeinstellung Data Delay ist für das Monitoring geeignet Die typische Bildschirmausrichtung ändert sich und verwendet eine Verzögerung von 200.000 Mikrosekunden. Sie können andere Datenverzögerungen wie SENSOR_DELAY_GAME (20.000 Mikrosekunden) Verzögerung), SENSOR_DELAY_UI (60.000 Mikrosekunden Verzögerung) oder SENSOR_DELAY_FASTEST (Verzögerung von 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. Als Best Practice sollten Sie die größte Verzögerung angeben, die möglich ist, da verwendet das System in der Regel eine geringere Verzögerung als die von Ihnen angegebene Verzögerung (d. h., Sie sollten der langsamsten Sampling-Rate, die dennoch den Anforderungen Ihrer Anwendung entspricht). 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. In diesem Fall sollten Sie die 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 sich der Bildschirm ausschaltet.

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 von Sensoren in einer Vielzahl von 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 während der Laufzeit erkennen

Wenn Ihre Anwendung einen bestimmten Sensortyp verwendet, diesen aber nicht nutzt, können Sie den Sensor-Framework, um den Sensor zur Laufzeit zu erkennen und dann Anwendungsfunktionen zu deaktivieren oder zu aktivieren . Eine Navigationsanwendung könnte beispielsweise den Temperatursensor, Drucksensor, GPS-Sensor und Sensor für geomagnetisches Feld zur Anzeige der Temperatur, barometrischer Druck, Position und Kompasspeilung. 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:

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 die <uses-feature> -Element in Ihrer Manifestdatei, um Ihre App von Geräten zu filtern, die keine über die richtige Sensorkonfiguration für Ihre Anwendung verfügen. Die Das Element <uses-feature> enthält mehrere Hardwaredeskriptoren, mit denen Sie filtern können bestimmten Sensoren basieren. 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 Deskriptor zum Manifest Ihrer Anwendung hinzufügen, sehen Nutzer Ihre App nur dann bei Google Play herunterladen, wenn das Gerät über einen Beschleunigungsmesser verfügt.

Sie sollten den Deskriptor nur dann auf android:required="true" festlegen, wenn Ihre Anwendung auf einen bestimmten Sensor basiert. Wenn Ihre Anwendung für einige Funktionen einen Sensor verwendet, läuft auch ohne den Sensor, sollten Sie ihn in die <uses-feature> eintragen -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 Bildschirm des Geräts definiert, wenn das Gerät in der Standardausrichtung gehalten wird (siehe Abbildung 1). Wird ein Gerät in der Standardausrichtung gehalten, Die X-Achse ist horizontal und zeigt nach rechts, die Y-Achse ist vertikal und zeigt nach oben und die Z zeigt zur Außenseite der Bildschirmfläche. Bei diesem System werden die Koordinaten hinter dem Bildschirm negative Z-Werte haben. Dieses Koordinatensystem wird von den folgenden Sensoren verwendet:

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

• Beschleunigung Sensor
• Schwerkraft Sensor
• Gyroskop
• Lineare Beschleunigung Sensor
• Geomagnetisches Feld Sensor

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 Verhalten des OpenGL- Koordinatensystem.

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()-Methode für die Zuordnung Sensorkoordinaten in Bildschirmkoordinaten ein. Das müssen Sie auch dann tun, wenn in Ihrem Manifest angegeben ist, im Hochformat.

Hinweis:Einige Sensoren und Methoden nutzen ein Koordinatensystem, relativ zum Bezugsrahmen der Welt (im Gegensatz zum Bezugsrahmen des Geräts). 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

Sensorratenbegrenzung

Zum Schutz potenziell vertraulicher Nutzerdaten, wenn deine App auf Unter Android 12 (API-Level 31) oder höher legt das System ein Limit für die Aktualisierung fest. Datenfrequenz bestimmter Bewegungs- und Positionssensoren. 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 Sie die Methode registerListener() zur Überwachung von Sensorereignissen verwenden, ist die Sensor-Abtastrate begrenzt auf 200 Hz. Dies gilt für alle überlasteten Varianten des registerListener()-Methode.
• Wenn Sie das Klasse SensorDirectChannel, ist die Sensor-Abtastrate auf RATE_NORMAL, normalerweise bei etwa 50 Hz.

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. Wenn Ihre App versucht, Daten des Bewegungssensors mit einer höheren Rate zu erheben, ohne diese Berechtigung zu erteilen, ein SecurityException auftritt.

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 beim Entwerfen Ihrer Sensorimplementierung die Richtlinien in den diesem Abschnitt. Diese Richtlinien stellen Best Practices für alle Nutzer des Sensors dar. für den Zugriff auf Sensoren und zur Erfassung von Sensordaten.

Sensordaten nur 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:

• Sensoren, die den fortlaufend wie im Berichtsmodus (Beschleunigungsmesser und Gyroskope) angezeigt, Ereignisse.
• 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

Achten Sie darauf, die Registrierung des Sensors aufzuheben, wenn Sie den Sensor nicht mehr benötigen oder die Aktivitä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:

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. (Falls auf dem Gerät Android 4.0 ausgeführt wird, muss es über Version 2 installiert) Die App SdkControllerSensor überwacht Änderungen in des Geräts und sendet sie an den Emulator. Der Emulator ist basierend auf den neuen Werten transformiert, die auf deinem Gerät.

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

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

So kannst du Daten zwischen deinem Gerät und dem Emulator übertragen: Schritte:

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:

$ adb forward tcp:1968 tcp:1968

6. Starten Sie den Emulator. Sie sollten jetzt in der Lage sein, Transformationen auf die Emulator öffnen.

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. Als Best Practice sollten Sie sollte mit der Methode onSensorChanged(SensorEvent) so wenig wie möglich unternehmen, damit sie nicht blockiert wird. Wenn Ihr Anwendung erfordert, dass Sie Daten filtern oder Sensordaten reduzieren, die außerhalb der onSensorChanged(SensorEvent)-Methode funktionieren.

Nicht mehr unterstützte Methoden oder Sensortypen verwenden

Mehrere Methoden und Konstanten wurden eingestellt. Insbesondere die TYPE_ORIENTATION Sensortyp wurde eingestellt. Zum Abrufen von Ausrichtungsdaten sollten Sie stattdessen die Methode getOrientation() verwenden. Ebenso gilt: Der Sensortyp „TYPE_TEMPERATURE“ wurde eingestellt. Sie sollten auf Geräten stattdessen den Sensortyp „TYPE_AMBIENT_TEMPERATURE“ auf denen Android 4.0 ausgeführt wird.

Prüfen Sie die Sensoren vor der Verwendung

Prüfen Sie immer, ob ein Sensor auf einem Gerät vorhanden ist, bevor Sie versuchen, Daten von ihm zu erfassen. Das sollten Sie nicht tun: dass ein Sensor existiert, einfach weil es sich um einen häufig genutzten Sensor handelt. Gerätehersteller sind keine bestimmten Sensoren in ihren Geräten bereitstellen müssen.

Sensorverzögerungen sorgfältig auswählen

Wenn du einen Sensor mit der Methode registerListener() registrierst, achte darauf, dass du eine Versandgeschwindigkeit auswählst, die für dein Anwendung oder Anwendungsfall. Sensoren können Daten mit sehr hohen Frequenzen liefern. Wenn Sie dem System erlauben, zusätzliche Daten, die Sie nicht benötigen, verschwenden Systemressourcen und verbrauchen Akkuleistung.