Inhalt

• Welche Android-Sensoren kann ich verwenden?
• Umgebungssensoren: Messung des Umgebungslichts
• Anzeige Ihrer Sensordaten
• Kommunikation mit einem Sensor: SensorManager, SensorEvents und Listener
• 1. Besorgen Sie sich eine Instanz von SensorManager
• 2. Holen Sie sich einen Verweis auf lightTextView
• 3. Überprüfen Sie, ob der Sensor auf dem aktuellen Gerät vorhanden ist
• 4. Registrieren Sie Ihre Sensor-Listener
• 5. Implementieren Sie die SensorEventListener-Rückrufe
• onSensorChanged ()
• onAccuracyChanged ()
• 6. Rufen Sie den Sensorwert ab
• 7. Heben Sie die Registrierung Ihrer Hörer auf
• Verwenden der Lichtsensoren von Android: Code abgeschlossen
• Testen Sie Ihre fertige Android-Sensor-App
• Entfernungsmessung mit den Näherungssensoren von Android
• Erstellen der Benutzeroberfläche
• Daten vom Näherungssensor abrufen
• Testen: Wie nah ist der Benutzer an seinem Gerät?
• Bewegungssensoren: Verarbeitung mehrdimensionaler Arrays
• Anzeige von Nick- und Rolldaten in Echtzeit
• Verwenden des Rotationsvektorsensors in Ihrer App
• 1. Verwenden Sie den TYPE_ROTATION_VECTOR
• 2. Übersetzen Sie die Sensordaten
• 3. Aktualisieren Sie die Platzhalterzeichenfolgen
• Anzeigen mehrerer Sensordaten: Code abgeschlossen
• Testen unserer letzten Android-Sensoranwendung
• Einpacken

Heutzutage sind die meisten modernen Android-Geräte mit einer Reihe von Sensoren ausgestattet.

Sie können diese Informationen auf viele verschiedene Arten verwenden - unabhängig davon, ob die Lichtverhältnisse überwacht werden, damit Ihre Anwendung die Helligkeit oder das Farbschema automatisch anpassen kann. Ermöglichen, dass der Benutzer mit Gesten wie dem Neigen seines Geräts mit Ihrem Handyspiel interagiert. oder den Näherungssensor verwenden, um Berührungsereignisse automatisch zu deaktivieren, wenn der Benutzer sein Gerät ans Ohr hält.

In diesem Artikel werden drei Anwendungen erstellt, die Licht-, Näherungs- und Bewegungsdaten von einer Reihe von Hardware- und Softwaresensoren abrufen. Wir überwachen diese Android-Sensoren auch in Echtzeit, sodass Ihre Anwendung immer auf die neuesten Informationen zugreifen kann.

Am Ende dieses Artikels erfahren Sie, wie Sie ein einzelnes Datenelement aus einem Android-Sensor extrahieren und wie Sie mit Sensoren umgehen, die ihre Daten in Form eines mehrdimensionalen Arrays bereitstellen.

Welche Android-Sensoren kann ich verwenden?

Android-Sensoren können in folgende Kategorien unterteilt werden:

• Umgebungssensoren. Diese messen Umgebungsbedingungen wie Lufttemperatur, Luftdruck, Luftfeuchtigkeit und Umgebungslicht.

• Positionssensoren. Diese Kategorie umfasst Sensoren, die die physische Position des Geräts messen, z. B. Näherungssensoren und Geomagnetfeldsensoren.
  Bewegungssensoren. Diese Sensoren messen die Gerätebewegung und umfassen Beschleunigungsmesser, Schwerkraftsensoren, Gyroskope und Rotationsvektorsensoren.

Darüber hinaus können Sensoren Folgendes sein:

• Hardware basiert. Hierbei handelt es sich um physikalische Komponenten, die in das Gerät eingebaut sind und bestimmte Eigenschaften wie die Beschleunigung oder die Stärke der umgebenden Erdmagnetfelder direkt messen.
• Software-basierte, manchmal als virtuelle Sensoren oder Verbundsensoren bezeichnet. Diese sammeln normalerweise Daten von mehreren hardwarebasierten Sensoren. Gegen Ende dieses Artikels arbeiten wir mit dem Rotationsvektorsensor, einem Software-Sensor, der Daten vom Beschleunigungsmesser, Magnetometer und Gyroskop des Geräts kombiniert.

Umgebungssensoren: Messung des Umgebungslichts

Der Lichtsensor von Android misst das Umgebungslicht in Lux-Einheiten. Dies ist die Intensität des Lichts, die vom menschlichen Auge wahrgenommen wird. Der von einem Sensor gemeldete Lux-Wert kann von Gerät zu Gerät variieren. Wenn Ihre Anwendung konsistente Werte erfordert, müssen Sie die Rohdaten möglicherweise bearbeiten, bevor Sie sie in Ihrer Anwendung verwenden können.

In diesem Abschnitt erstellen wir eine Anwendung, die den aktuellen Lux-Wert vom Lichtsensor des Geräts abruft, ihn in einer Textansicht anzeigt und dann die Textansicht aktualisiert, sobald neue Daten verfügbar werden.Sie können diese Informationen dann in einer Reihe von Apps verwenden. Beispielsweise können Sie eine Taschenlampenanwendung erstellen, die Informationen vom Lichtsensor abruft und dann die Stärke des Strahls automatisch an die aktuellen Lichtverhältnisse anpasst.

Erstellen Sie ein neues Android-Projekt mit den Einstellungen Ihrer Wahl und legen Sie los!

Anzeige Ihrer Sensordaten

Ich werde eine Textansicht hinzufügen, in der die vom Lichtsensor extrahierten Daten angezeigt werden. Diese Textansicht wird aktualisiert, sobald neue Daten verfügbar sind, sodass der Benutzer immer auf die neuesten Informationen zugreifen kann.

Öffnen Sie die Datei activity_main.xml Ihres Projekts und fügen Sie Folgendes hinzu:

Als Nächstes müssen wir die String-Ressource "light_sensor" erstellen, auf die in unserem Layout verwiesen wird. Öffnen Sie die Datei "strings.xml" Ihres Projekts und fügen Sie Folgendes hinzu:

Lichtsensor:% 1 $ .2f

Der Platzhalter "% 1 $ .2f" gibt an, welche Informationen angezeigt werden sollen und wie sie formatiert werden sollen:

• %1. Sie können mehrere Platzhalter in dieselbe Zeichenfolgenressource einfügen. "% 1" gibt an, dass wir einen einzelnen Platzhalter verwenden.
• $.2. Dies gibt an, wie unsere Anwendung jeden eingehenden Gleitkommawert formatieren soll. Das "$ .2" gibt an, dass der Wert auf zwei Dezimalstellen gerundet werden sollte.
• F. Formatieren Sie den Wert als Gleitkommazahl.

Einige Sensoren sind zwar häufiger als andere, Sie sollten jedoch niemals davon ausgehen, dass jedes Gerät Zugriff auf genau dieselbe Hardware und Software hat. Die Sensorverfügbarkeit kann sogar bei verschiedenen Android-Versionen variieren, da einige Sensoren erst in späteren Versionen der Android-Plattform eingeführt wurden.

Mithilfe des Android-Sensor-Frameworks können Sie überprüfen, ob ein bestimmter Sensor auf einem Gerät vorhanden ist. Sie können dann Teile Ihrer Anwendung basierend auf der Verfügbarkeit des Sensors deaktivieren oder aktivieren oder eine Erklärung anzeigen, dass einige Funktionen Ihrer Anwendung nicht wie erwartet funktionieren.

Während unsere Datei "strings.xml" geöffnet ist, erstellen wir eine Zeichenfolge "no_sensor", die angezeigt wird, wenn der Lichtsensor nicht verfügbar ist:

Kein Lichtsensor vorhanden

Wenn Ihre Anwendung ohne Zugriff auf einen bestimmten Sensor keine gute Benutzererfahrung bieten kann, müssen Sie diese Informationen zu Ihrem Manifest hinzufügen. Wenn Ihre App beispielsweise Zugriff auf einen Kompasssensor erfordert, können Sie Folgendes verwenden:

Jetzt kann Ihre App nur auf Geräte heruntergeladen werden, die über einen Kompasssensor verfügen.

Dies kann Ihre Zielgruppe zwar einschränken, ist jedoch weitaus weniger schädlich, als wenn Sie zulassen, dass jemand Ihre Anwendung herunterlädt, wenn er dies tut garantiert aufgrund der Sensorkonfiguration des Geräts schlechte Erfahrungen zu machen.

Kommunikation mit einem Sensor: SensorManager, SensorEvents und Listener

Um mit dem Lichtsensor des Geräts zu kommunizieren, müssen Sie die folgenden Schritte ausführen:

1. Besorgen Sie sich eine Instanz von SensorManager

Der SensorManager bietet alle Methoden, um auf alle Sensoren des Geräts zuzugreifen.

Erstellen Sie zunächst eine Variable, die eine Instanz von SensorManager enthält:

privater SensorManager lightSensorManager;

Anschließend müssen Sie eine Instanz von SensorManager abrufen, indem Sie die Context.getSystemService-Methode aufrufen und das Context.SENSOR_SERVICE-Argument übergeben:

lightSensorManager = (SensorManager) getSystemService (Context.SENSOR_SERVICE);

2. Holen Sie sich einen Verweis auf lightTextView

Als Nächstes müssen wir eine private Mitgliedsvariable erstellen, die unsere TextView-Objekte enthält, und sie unserer TextView zuweisen:

private TextView lightTextView; ... ... ... lightTextView = (TextView) findViewById (R.id.lightTextView);

3. Überprüfen Sie, ob der Sensor auf dem aktuellen Gerät vorhanden ist

Sie können auf einen bestimmten Sensor zugreifen, indem Sie die Methode getDefaultSensor () aufrufen und diesen dann an den betreffenden Sensor übergeben. Die Typkonstante für den Lichtsensor ist TYPE_LIGHT, daher müssen wir Folgendes verwenden:

lightSensor = lightSensorManager.getDefaultSensor (Sensor.TYPE_LIGHT);

Wenn der Sensor auf diesem Gerät nicht vorhanden ist, gibt die getDefaultSensor () -Methode null zurück und wir zeigen die Zeichenfolge "no_sensor" an:

String sensor_error = getResources (). GetString (R.string.no_sensor); if (lightSensor == null) {lightTextView.setText (sensor_error); }}

4. Registrieren Sie Ihre Sensor-Listener

Jedes Mal, wenn ein Sensor neue Daten enthält, generiert Android ein SensorEvent-Objekt. Dieses SensorEvent-Objekt enthält den Sensor, der das Ereignis generiert hat, einen Zeitstempel und den neuen Datenwert.

Zunächst konzentrieren wir uns auf die Licht- und Näherungssensoren, die ein einzelnes Datenelement zurückgeben. Einige Sensoren bieten jedoch mehrdimensionale Arrays für jedes SensorEvent, einschließlich des Rotationsvektorsensors, den wir gegen Ende dieses Artikels untersuchen werden.

Um sicherzustellen, dass unsere Anwendung über diese SensorEvent-Objekte benachrichtigt wird, müssen wir mithilfe von registerListener () von SensorManager einen Listener für dieses spezielle Sensorereignis registrieren.

Die registerListener () -Methode akzeptiert die folgenden Argumente:

• Eine App oder ein Aktivitätskontext.
• Der Sensortyp, den Sie überwachen möchten.
• Die Rate, mit der der Sensor neue Daten senden soll. Eine höhere Rate versorgt Ihre Anwendung mit mehr Daten, beansprucht jedoch auch mehr Systemressourcen, insbesondere die Akkulaufzeit. Um den Akku des Geräts zu schonen, sollten Sie die Mindestmenge an Daten anfordern, die für Ihre Anwendung erforderlich sind. Ich verwende SensorManager.SENSOR_DELAY_NORMAL, der alle 200.000 Mikrosekunden (0,2 Sekunden) neue Daten sendet.

Da das Abhören eines Sensors die Batterie des Geräts entlädt, sollten Sie niemals Listener in der onCreate () -Methode Ihrer Anwendung registrieren, da die Sensoren dann weiterhin Daten senden, selbst wenn sich Ihre Anwendung im Hintergrund befindet.

Stattdessen sollten Sie Ihre Sensoren in der Lebenszyklusmethode onStart () der Anwendung registrieren:

@Override protected void onStart () {super.onStart (); // Wenn der Sensor auf dem aktuellen Gerät verfügbar ist ... // if (lightSensor! = Null) {//…. Dann fange an zu lauschen // lightSensorManager.registerListener (this, lightSensor, SensorManager.SENSOR_DELAY_NORMAL); }}

5. Implementieren Sie die SensorEventListener-Rückrufe

SensorEventListener ist eine Schnittstelle, die Benachrichtigungen vom SensorManager empfängt
sobald neue Daten verfügbar sind oder sich die Genauigkeit des Sensors ändert.

Der erste Schritt ist das Ändern unserer Klassensignatur, um die SensorEventListener-Schnittstelle zu implementieren:

public class MainActivity erweitert AppCompatActivity implementiert SensorEventListener {

Wir müssen dann die folgenden Rückrufmethoden implementieren:

onSensorChanged ()

Diese Methode wird als Antwort auf jedes neue SensorEvent aufgerufen.

Sensordaten können sich häufig schnell ändern, sodass Ihre Anwendung möglicherweise regelmäßig die Methode onSensorChanged () aufruft. Damit Ihre Anwendung reibungslos funktioniert, sollten Sie so wenig wie möglich in der onSensorChanged () -Methode arbeiten.

@Override public void onSensorChanged (SensorEvent sensorEvent) {// To do //}

onAccuracyChanged ()

Wenn sich die Genauigkeit des Sensors verbessert oder verringert, ruft Android die Methode onAccuracyChanged () auf und übergibt ihr ein Sensorobjekt mit dem neuen Genauigkeitswert, z. B. SENSOR_STATUS_UNRELIABLE oder SENSOR_STATUS_ACCURACY_HIGH.

Der Lichtsensor meldet keine Genauigkeitsänderungen. Daher lasse ich den Rückruf für onAccuracyChanged () leer:

@Override public void onAccuracyChanged (Sensorsensor, int i) {// Zu erledigen //}}

6. Rufen Sie den Sensorwert ab

Immer wenn wir einen neuen Wert haben, müssen wir die onSensorChanged () -Methode aufrufen und die Zeichenfolge "light_sensor" abrufen. Wir können dann den Platzhaltertext der Zeichenfolge (% 1 $ .2f) überschreiben und die aktualisierte Zeichenfolge als Teil unserer TextView anzeigen:

@Override public void onSensorChanged (SensorEvent sensorEvent) {// Der aktuelle Wert des Sensors // float currentValue = sensorEvent.values; // Den String "light_sensor" abrufen, den neuen Wert einfügen und dem Benutzer anzeigen // lightTextView.setText (getResources (). GetString (R.string.light_sensor, currentValue)); }

7. Heben Sie die Registrierung Ihrer Hörer auf

Sensoren können große Datenmengen in kurzer Zeit generieren. Um die Ressourcen des Geräts zu schonen, müssen Sie die Registrierung Ihrer Listener aufheben, wenn diese nicht mehr benötigt werden.

Fügen Sie unregisterListener () zur onStop () -Lebenszyklusmethode Ihres Projekts hinzu, um das Abhören von Sensorereignissen zu beenden, wenn sich Ihre Anwendung im Hintergrund befindet:

@Override protected void onStop () {super.onStop (); lightSensorManager.unregisterListener (this); }

Beachten Sie, dass Sie die Registrierung Ihrer Hörer in onPause () nicht aufheben sollten, da in Android 7.0 und höher Anwendungen im geteilten Bildschirm und im Bild-in-Bild-Modus ausgeführt werden können, wenn sie angehalten sind, aber weiterhin auf dem Bildschirm angezeigt werden.

Verwenden der Lichtsensoren von Android: Code abgeschlossen

Nachdem Sie alle oben genannten Schritte ausgeführt haben, sollte die MainActivity Ihres Projekts ungefähr so ​​aussehen:

android.support.v7.app.AppCompatActivity importieren; android.os.Bundle importieren; android.content.Context importieren; android.hardware.Sensor importieren; android.hardware.SensorEvent importieren; android.hardware.SensorEventListener importieren; android.hardware.SensorManager importieren; import android.widget.TextView; public class MainActivity erweitert AppCompatActivity // Implementiere die SensorEventListener-Schnittstelle // implementiert SensorEventListener {// Erstelle deine Variablen // private Sensor lightSensor; privater SensorManager lightSensorManager; private TextView lightTextView; @Override protected void onCreate (Bundle savedInstanceState) {super.onCreate (savedInstanceState); setContentView (R.layout.activity_main); lightTextView = (TextView) findViewById (R.id.lightTextView); // Instanz von SensorManager abrufen // lightSensorManager = (SensorManager) getSystemService (Context.SENSOR_SERVICE); // Nach einem Lichtsensor suchen // lightSensor = lightSensorManager.getDefaultSensor (Sensor.TYPE_LIGHT); // Wenn der Lichtsensor nicht vorhanden ist, wird ein Fehler angezeigt. // String sensor_error = getResources (). GetString (R.string.no_sensor); if (lightSensor == null) {lightTextView.setText (sensor_error); }} @Override protected void onStart () {super.onStart (); // Wenn der Sensor auf dem aktuellen Gerät verfügbar ist ... // if (lightSensor! = Null) {//... dann einen Listener registrieren. // lightSensorManager.registerListener (this, lightSensor, // Geben Sie an, wie oft Sie möchten neue Daten empfangen // SensorManager.SENSOR_DELAY_NORMAL); }} @Override protected void onStop () {super.onStop (); // Den Listener abmelden // lightSensorManager.unregisterListener (this); } @Override public void onSensorChanged (SensorEvent sensorEvent) {// Der aktuelle Wert des Sensors // float currentValue = sensorEvent.values; // Rufe den String "light_sensor" ab, füge den neuen Wert ein und aktualisiere die // TextView lightTextView.setText (getResources (). GetString (R.string.light_sensor, currentValue)); } @Override // Wenn sich die Genauigkeit des Sensors ändert… .// public void onAccuracyChanged (Sensorsensor, int i) {// TO DO //}}

Testen Sie Ihre fertige Android-Sensor-App

So testen Sie diese Anwendung auf einem physischen Android-Smartphone oder -Tablet:

• Installieren Sie das Projekt auf Ihrem Gerät (indem Sie in der Android Studio-Symbolleiste auf „Ausführen“ klicken).
• Obwohl es von Gerät zu Gerät unterschiedlich ist, befindet sich der Lichtsensor häufig oben rechts auf dem Bildschirm. Bewegen Sie das Gerät näher an eine Lichtquelle und weiter von dieser entfernt, um die Lichtstärke zu ändern. Alternativ können Sie versuchen, das Gerät mit der Hand abzudecken, um das Licht auszublenden. Der Wert für „Lichtsensor“ sollte abhängig von der verfügbaren Lichtmenge steigen und fallen.

Wenn Sie ein virtuelles Android-Gerät (AVD) verwenden, verfügt der Emulator über eine Reihe virtueller Sensorsteuerelemente, mit denen Sie verschiedene Sensorereignisse simulieren können. Sie greifen über das Fenster "Erweiterte Steuerelemente" des Emulators auf diese virtuellen Sensorsteuerelemente zu:

• Installieren Sie die Anwendung auf Ihrem AVD.
• Neben der AVD sehen Sie eine Reihe von Schaltflächen. Suchen Sie die dreipunktige Schaltfläche „Mehr“ (in der folgenden Abbildung befindet sich der Cursor) und klicken Sie darauf. Dadurch wird das Fenster "Erweiterte Steuerelemente" geöffnet.

• Wählen Sie im linken Menü "Virtuelle Sensoren".
• Wählen Sie die Registerkarte „Zusätzliche Sensoren“. Diese Registerkarte enthält verschiedene Schieberegler, mit denen Sie verschiedene Positions- und Umgebungssensorereignisse simulieren können.

• Suchen Sie den Schieberegler „Licht (Lux)“ und ziehen Sie ihn nach links und rechts, um die simulierten Lichtpegel zu ändern. Ihre Anwendung sollte diese sich ändernden Werte in Echtzeit anzeigen.

Sie können das fertige Projekt von GitHub herunterladen.

Entfernungsmessung mit den Näherungssensoren von Android

Nun haben wir gesehen, wie Sie Informationen von einem Umweltsensor abrufen. Schauen wir uns an, wie Sie dieses Wissen auf einen Sensor anwenden würden Position Sensor.

In diesem Abschnitt verwenden wir den Näherungssensor des Geräts, um den Abstand zwischen Ihrem Smartphone oder Tablet und anderen Objekten zu überwachen. Wenn Ihre Anwendung über Sprachfunktionen verfügt, können Sie mithilfe des Näherungssensors feststellen, wann das Smartphone an das Ohr des Benutzers gehalten wird, z. B. während eines Telefongesprächs. Sie können diese Informationen dann verwenden, um Berührungsereignisse zu deaktivieren, damit der Benutzer nicht versehentlich auflegt oder andere unerwünschte Ereignisse während einer Unterhaltung auslöst.

Erstellen der Benutzeroberfläche

Ich werde die Näherungsdaten auf dem Bildschirm anzeigen, damit Sie sie in Echtzeit aktualisieren können. Verwenden wir zur Vereinfachung einen Großteil des Layouts aus unserer vorherigen Anwendung:

Öffnen Sie als Nächstes Ihre Datei "strings.xml" und erstellen Sie eine Zeichenfolge "proximity_sensor". Diese Zeichenfolge muss wieder einen Platzhalter enthalten, der schließlich mit Daten gefüllt wird, die vom Näherungssensor extrahiert wurden:

ProximitySensor Näherungssensor:% 1 $ .2f Kein Näherungssensor vorhanden

Daten vom Näherungssensor abrufen

Ähnlich wie der Lichtsensor gibt der Näherungssensor von Android einen einzelnen Datenwert zurück, sodass wir einen Großteil des Codes aus unserer vorherigen Anwendung wiederverwenden können. Es gibt jedoch einige Hauptunterschiede sowie einige namensbezogene Änderungen, die das Befolgen dieses Codes erleichtern:

• Erstellen Sie eine Instanz von SensorManager. Dieses Mal werde ich den Namen "proximitySensorManager" verwenden.
• Beziehen Sie eine Instanz von "proximitySensorManager".
• Erstellen Sie einen Verweis auf "proximityTextView".
• Rufen Sie die Methode getDefaultSensor () auf und übergeben Sie sie dem Sensor TYPE_PROXIMITY.
• Registrieren Sie die Listener für den Näherungssensor und heben Sie die Registrierung auf.

Nachdem Sie diese Änderungen vorgenommen haben, sollten Sie Folgendes feststellen:

android.support.v7.app.AppCompatActivity importieren; android.os.Bundle importieren; android.content.Context importieren; android.hardware.Sensor importieren; android.hardware.SensorEvent importieren; android.hardware.SensorManager importieren; android.hardware.SensorEventListener importieren; import android.widget.TextView; public class MainActivity erweitert AppCompatActivity // Implementiere die SensorEventListener-Schnittstelle // implementiert SensorEventListener {// Erstelle deine Variablen // private Sensor proximitySensor; private SensorManager proximitySensorManager; private TextView proximityTextView; @Override protected void onCreate (Bundle savedInstanceState) {super.onCreate (savedInstanceState); setContentView (R.layout.activity_main); proximityTextView = (TextView) findViewById (R.id.proximityTextView); // Instanz von SensorManager abrufen // proximitySensorManager = (SensorManager) getSystemService (Context.SENSOR_SERVICE); // Auf einen Näherungssensor prüfen // proximitySensor = proximitySensorManager.getDefaultSensor (Sensor.TYPE_PROXIMITY); // Wenn der Näherungssensor nicht vorhanden ist, wird ein Fehler angezeigt. // String sensor_error = getResources (). GetString (R.string.no_sensor); if (proximitySensor == null) {proximityTextView.setText (sensor_error); }} @Override protected void onStart () {super.onStart (); // Wenn der Sensor auf dem aktuellen Gerät verfügbar ist ... // if (proximitySensor! = Null) {//… .dann einen Listener registrieren. // proximitySensorManager.registerListener (this, proximitySensor, // Geben Sie an, wie oft Sie möchten neue Daten empfangen // SensorManager.SENSOR_DELAY_NORMAL); }} @Override protected void onStop () {super.onStop (); // Heben Sie die Registrierung Ihres Listeners auf, um Systemressourcen zu erhalten. // proximitySensorManager.unregisterListener (this); } @Override public void onSensorChanged (SensorEvent sensorEvent) {// Der aktuelle Wert des Sensors // float currentValue = sensorEvent.values; // Rufe die Zeichenfolge "proximity_sensor" ab, füge den neuen Wert ein und aktualisiere die // TextView proximityTextView.setText (getResources (). GetString (R.string.proximity_sensor, currentValue)); } @Override // Wenn sich die Genauigkeit des Sensors ändert… .// public void onAccuracyChanged (Sensorsensor, int i) {//...TO DO //}}

Testen: Wie nah ist der Benutzer an seinem Gerät?

Um diese Anwendung auf einem physischen Android-Smartphone oder -Tablet zu testen, installieren Sie sie auf Ihrem Gerät und experimentieren Sie, indem Sie Ihre Hand auf den Bildschirm richten und dann wieder wegbewegen. Der Wert „Näherungssensor“ sollte Ihre Bewegungen aufzeichnen.

Beachten Sie jedoch, dass die Näherungssensoren von Gerät zu Gerät unterschiedlich sein können. Einige Geräte zeigen möglicherweise nur zwei Näherungswerte an - einen für "Nah" und einen für "Fern". Seien Sie also nicht überrascht, wenn Sie auf Ihrem physischen Android-Gerät keine große Vielfalt feststellen.

So testen Sie diese Anwendung auf einem Emulator:

• Installieren Sie Ihre Anwendung auf einer AVD.
• Suchen Sie die dreipunktige Schaltfläche "Mehr" und klicken Sie darauf, um das Fenster "Erweiterte Steuerelemente" zu öffnen.
• Wählen Sie im linken Menü des Fensters "Virtuelle Sensoren".
• Wählen Sie die Registerkarte „Zusätzliche Sensoren“.
• Suchen Sie den Schieberegler „Nähe“ und ziehen Sie ihn nach links und rechts, um ein Objekt zu emulieren, das sich näher an das Gerät und dann weiter entfernt befindet. Die Werte für „Näherungssensor“ sollten sich ändern, wenn Sie den Schieberegler betätigen.

Sie können das fertige Projekt von GitHub herunterladen.

Bewegungssensoren: Verarbeitung mehrdimensionaler Arrays

Bisher haben wir uns auf Sensoren konzentriert, die ein einzelnes Datenelement liefern. Es gibt jedoch auch Sensoren, die mehrdimensionale Arrays für jedes SensorEvent bereitstellen. Zu diesen mehrdimensionalen Sensoren gehören Bewegungssensoren, auf die wir uns in diesem letzten Abschnitt konzentrieren werden.

Bewegungssensoren können Ihnen helfen:

• Geben Sie eine alternative Methode zur Benutzereingabe an. Wenn Sie beispielsweise ein Handyspiel entwickeln, kann der Benutzer seinen Charakter durch Neigen des Geräts auf dem Bildschirm bewegen.
• Benutzeraktivität ableiten. Wenn Sie eine Aktivitäts-Tracking-App erstellt haben, können Sie mithilfe von Bewegungssensoren feststellen, ob der Benutzer im Auto fährt, joggt oder an seinem Schreibtisch sitzt.
• Die Ausrichtung genauer bestimmen.Es ist möglich, Koordinaten von den Bewegungssensoren eines Geräts zu extrahieren und sie dann basierend auf dem Koordinatensystem der Erde zu übersetzen, um den genauesten Einblick in die aktuelle Ausrichtung des Geräts zu erhalten.

In diesem letzten Abschnitt verwenden wir den Rotationsvektorsensor (TYPE_ROTATION_VECTOR). Im Gegensatz zu den Licht- und Näherungssensoren ist dies ein Softwaresensor, der Daten von den Beschleunigungsmesser-, Magnetometer- und Gyroskopsensoren des Geräts sammelt. Wenn Sie mit diesem Sensor arbeiten, müssen Sie zwar häufig mathematische Konvertierungen und Transformationen durchführen, Sie erhalten jedoch auch eine Reihe hochgenauer Informationen über das Gerät.

Wir werden eine Anwendung erstellen, die den Rotationsvektorsensor verwendet, um Folgendes zu messen:

• Tonhöhe. Dies ist die Neigung des Geräts von oben nach unten.
• Rollen. Dies ist die Neigung des Geräts von links nach rechts.

Anzeige von Nick- und Rolldaten in Echtzeit

Da wir zwei Metriken messen, müssen wir zwei TextViews und zwei entsprechende Zeichenfolgenressourcen erstellen:

Öffnen Sie die Datei strings.xml und fügen Sie Folgendes hinzu:

Bewegungssensoren Neigungssensor:% 1 $ .2f Rollsensor:% 1 $ .2f Kein Bewegungssensor vorhanden

Verwenden des Rotationsvektorsensors in Ihrer App

Wir werden einen Teil des Codes aus unseren vorherigen Anwendungen wiederverwenden. Konzentrieren wir uns daher auf die Bereiche, in denen die Kommunikation mit dem Rotationsvektorsensor erheblich von dem abweicht, was wir zuvor gesehen haben.

1. Verwenden Sie den TYPE_ROTATION_VECTOR

Da wir mit dem Rotationsvektorsensor arbeiten, müssen wir die getDefaultSensor () -Methode aufrufen und anschließend die TYPE_ROTATION_VECTOR-Konstante übergeben:

positionSensorManager.getDefaultSensor (Sensor.TYPE_ROTATION_VECTOR);

2. Übersetzen Sie die Sensordaten

Im Gegensatz zu den vorherigen Licht- und Näherungssensoren geben Bewegungssensoren mehrdimensionale Arrays von Sensorwerten für jedes SensorEvent zurück. Diese Werte werden unter Verwendung des Standardkoordinatensystems "X, Y, Z" formatiert, das relativ zum Gerät berechnet wird, wenn es in seiner standardmäßigen "natürlichen" Ausrichtung gehalten wird.

Android ändert diese X-, Y- und Z-Koordinaten nicht entsprechend der aktuellen Ausrichtung des Geräts, sodass die X-Achse unabhängig davon, ob sich das Gerät im Hoch- oder Querformat befindet, unverändert bleibt. Wenn Sie den Rotationsvektorsensor verwenden, müssen Sie möglicherweise die eingehenden Daten konvertieren, um sie an die aktuelle Rotation des Geräts anzupassen.

Die Standardausrichtung für die meisten Smartphones ist Hochformat. Sie sollten jedoch nicht davon ausgehen, dass dies der Fall sein wird alle Android-Geräte, insbesondere Tablets. In diesem Artikel verwenden wir eine Rotationsmatrix, um die Daten des Sensors von seinen ursprünglichen, Gerät Koordinatensystem zum Der Erde Koordinatensystem, das die Bewegung und Position des Geräts relativ zur Erde darstellt. Bei Bedarf können wir dann die Sensordaten basierend auf der aktuellen Ausrichtung des Geräts neu zuordnen.

Erstens ist das Gerätekoordinatensystem ein standardmäßiges 3-Achsen-X-, Y- und Z-Koordinatensystem, bei dem jeder Punkt auf jeder der drei Achsen durch einen 3D-Vektor dargestellt wird. Dies bedeutet, dass wir ein Array mit 9 Gleitkommawerten erstellen müssen:

float rotationMatrix = neuer Schwimmer;

Wir können dieses Array dann an die Methode getRotationMatrix () übergeben:

SensorManager.getRotationMatrixFromVector (rotationMatrix, vectors); int worldAxisX = SensorManager.AXIS_X; int worldAxisZ = SensorManager.AXIS_Z;

Der nächste Schritt ist die Verwendung der SensorManager.remapCoordinateSystem () -Methode, um die Sensordaten basierend auf der aktuellen Ausrichtung des Geräts neu zuzuordnen.

Die SensorManager.remapCoordinateSystem () -Methode akzeptiert die folgenden Argumente:

• Die ursprüngliche Rotationsmatrix.
• Die Achsen, die Sie neu zuordnen möchten.
• Das Array, das Sie mit diesen neuen Daten füllen.

Hier ist der Code, den ich in meiner App verwende:

float adjustedRotationMatrix = neuer float; SensorManager.remapCoordinateSystem (rotationMatrix, worldAxisX, worldAxisZ, adjustedRotationMatrix);

Abschließend rufen wir SensorManager.getOrientation auf und weisen es an, die adjustierte Rotationsmatrix zu verwenden:

SensorManager.getOrientation (adjustierte Rotationsmatrix, Orientierung);

3. Aktualisieren Sie die Platzhalterzeichenfolgen

Da wir über zwei Datensätze (Pitch und Roll) verfügen, müssen wir zwei separate Platzhalterzeichenfolgen abrufen, diese mit den richtigen Werten füllen und dann die entsprechende Textansicht aktualisieren:

pitchTextView.setText (getResources (). getString (R.string.pitch_sensor, pitch)); rollTextView.setText (getResources (). getString (R.string.roll_sensor, roll));

Anzeigen mehrerer Sensordaten: Code abgeschlossen

Nachdem Sie die obigen Schritte ausgeführt haben, sollte Ihre MainActivity ungefähr so ​​aussehen:

android.app.Activity importieren; android.os.Bundle importieren; android.hardware.Sensor importieren; android.hardware.SensorEvent importieren; android.hardware.SensorEventListener importieren; android.hardware.SensorManager importieren; import android.widget.TextView; public class MainActivity extended Activity implementiert SensorEventListener {private SensorManager motionSensorManager; private Sensor motionSensor; private TextView pitchTextView; private TextView rollTextView; private static final int SENSOR_DELAY = 500 * 1000; private static final int FROM_RADS_TO_DEGS = -57; @Override protected void onCreate (Bundle savedInstanceState) {super.onCreate (savedInstanceState); setContentView (R.layout.activity_main); pitchTextView = (TextView) findViewById (R.id.pitchTextView); rollTextView = (TextView) findViewById (R.id.rollTextView); try {motionSensorManager = (SensorManager) getSystemService (Activity.SENSOR_SERVICE); motionSensor = motionSensorManager.getDefaultSensor (Sensor.TYPE_ROTATION_VECTOR); motionSensorManager.registerListener (this, motionSensor, SENSOR_DELAY); } catch (Ausnahme e) {pitchTextView.setText (R.string.no_sensor); rollTextView.setText (R.string.no_sensor); }} @Override public void onAccuracyChanged (Sensorsensor, int Genauigkeit) {// To do //} @Override public void onSensorChanged (SensorEvent Ereignis) {if (event.sensor == motionSensor) {update (event.values); }} Private Void-Aktualisierung (Float-Vektoren) {// Berechne die Rotationsmatrix // float rotationMatrix = new float; SensorManager.getRotationMatrixFromVector (rotationMatrix, vectors); int worldAxisX = SensorManager.AXIS_X; int worldAxisZ = SensorManager.AXIS_Z; // Ordne die Matrix basierend auf der aktuellen Ausrichtung der Aktivität neu zu // float adjustiertRotationMatrix = new float; SensorManager.remapCoordinateSystem (rotationMatrix, worldAxisX, worldAxisZ, adjustedRotationMatrix); // Berechne die Geräteorientierung // float guidance = new float; // Das Array von Float-Werten an die Methode getOrientation () übergeben. // SensorManager.getOrientation (adjustierteRotationMatrix, Ausrichtung); Float Pitch = Orientierung * FROM_RADS_TO_DEGS; Float Roll = Orientierung * FROM_RADS_TO_DEGS; // Aktualisiere die TextViews mit den Pitch- und Roll-Werten // pitchTextView.setText (getResources (). GetString (R.string.pitch_sensor, pitch)); rollTextView.setText (getResources (). getString (R.string.roll_sensor, roll)); }}

Sie können das fertige Projekt von GitHub herunterladen.

Testen unserer letzten Android-Sensoranwendung

So testen Sie diese Rotationsvektor-Android-Sensor-App auf einem physischen Android-Smartphone oder -Tablet:

• Installieren Sie die Anwendung auf Ihrem Gerät.
• Stellen Sie Ihr Smartphone oder Tablet auf eine ebene Fläche. Beachten Sie, dass Bewegungssensoren äußerst empfindlich sind. Daher ist es nicht ungewöhnlich, dass ein scheinbar bewegungsloses Gerät Schwankungen der Nick- und Rollwerte meldet.
• Heben Sie zum Testen der Tonhöhe die Unterseite des Geräts an, sodass es von Ihnen wegkippt. Der Tonhöhenwert sollte sich dramatisch ändern.
• Heben Sie zum Testen der Rolle die linke Seite des Geräts an, sodass es nach links geneigt ist. Behalten Sie den Rollwert im Auge!

Wenn Sie Ihr Projekt auf einem Emulator testen:

• Installieren Sie die Anwendung auf Ihrem AVD.
• Wählen Sie "More", um das Fenster "Extended Controls" zu öffnen.
• Wählen Sie im linken Menü "Virtuelle Sensoren".
• Stellen Sie sicher, dass die Registerkarte "Beschleunigungsmesser" ausgewählt ist. Diese Registerkarte enthält Steuerelemente, mit denen Änderungen der Position und Ausrichtung des Geräts simuliert werden können.
• Versuchen Sie, mit den verschiedenen Schiebereglern (Drehen: Z-Rot, X-Rot, Y-Rot und Bewegen: X, Y und Z) und den verschiedenen Schaltflächen für die Gerätedrehung zu experimentieren, um festzustellen, wie sie sich auf den „Rollsensor“ Ihrer Anwendung auswirken ”Und“ Pitch Sensor ”.

Einpacken

In diesem Artikel haben wir gesehen, wie Daten aus den drei Hauptkategorien von Android-Sensoren abgerufen werden: Umgebung, Position und Bewegung, und wie diese Daten in Echtzeit überwacht werden.

Haben Sie Android-Apps gesehen, die Sensoren auf interessante oder einzigartige Weise verwenden? Lass es uns in den Kommentaren unten wissen!