Anleitung für Software-Entwickler zu Sensoren auf Android*-Tablets mit Intel® Atom™ Prozessor

Kurzfassung

Diese Anleitung bietet Anwendungsentwicklern eine Einführung in das Android*-Sensor-Framework und beschreibt den Einsatz einiger der auf gängigen Tablets mit Intel® Atom™ Prozessor allgemein verfügbaren Sensoren. Unter anderem werden Bewegungs-, Positions- und Umgebungssensoren behandelt. Streng genommen ist GPS zwar nicht als Sensor definiert, aber in diesem Artikel werden dennoch GPS-basierte Standortdienste besprochen.

1 Sensoren auf Android*-Tablets mit Intel® Atom™ Prozessor

Tablets, die mit einem System-on-a-Chip (SoC) auf Basis des Intel® Atom™ Prozessors ausgestattet sind, bieten Unterstützung für eine große Auswahl von Hardwaresensoren. Diese Sensoren können Bewegungs- und Positionsänderungen erkennen und Umgebungsparameter melden. Das folgende Blockdiagramm zeigt eine mögliche Sensorkonfiguration auf einem typischen Android*-Tablet mit Intel Atom Prozessor:


Abb. 1-1 Sensoren auf einem Tablet mit Intel® Atom™ SoC

Tablet-Sensoren lassen sich basierend auf den von ihnen gemeldeten Daten in folgende Kategorien und Typen unterteilen:

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

Kategorie Sensor Beschreibung Verwendung
Bewegungssensoren Beschleunigungssensor (TYPE_ACCELEROMETER) Misst die Beschleunigung des Geräts in m/s2 Bewegungserkennung
Gyroskop bzw. Kreiselsensor (TYPE_GYROSCOPE) Misst die Drehrate eines Geräts Rotationserkennung
Positionssensoren Magnetometer (TYPE_MAGNETIC_FIELD) Misst die Erdmagnetfeldstärke in µT Kompass
Näherungssensor (TYPE_PROXIMITY) Misst den Abstand zu einem Objekt in cm Erkennen nahegelegener Objekte
GPS (kein Sensor des Typs android.hardware.Sensor) Ermittelt die präzise geografische Position des Geräts Präzise Ermittlung der geografischen Position
Umgebungssensoren ALS – Umgebungslichtsensor (TYPE_LIGHT) Misst die Umgebungslichtstärke in lx Automatische Anpassung der Bildschirmhelligkeit

2 Android*-Sensor-Framework

2.1 Übersicht

Das Android*-Sensor-Framework bietet Mechanismen für den Zugriff auf Sensoren und Sensordaten, mit Ausnahme von GPS, wo der Zugriff über die Android*-Standortdienste erfolgt. Hiermit beschäftigen wir uns weiter unten in diesem Artikel. Das Sensor-Framework gehört zum android.hardware-Paket. Die folgende Tabelle zeigt die wichtigsten Klassen und Schnittstellen des Sensor-Frameworks:

Tabelle 2-1 Das Sensor-Framework der Android-Plattform

Name Typ Beschreibung
SensorManager Klasse Wird für das Erstellen einer Instanz des Sensordienstes verwendet. Bietet verschiedene Methoden für den Zugriff auf Sensoren, die Registrierung und die Registrierungsaufhebung von Sensor-Event-Listenern usw.
Sensor Klasse Wird für das Erstellen einer Instanz eines bestimmten Sensors verwendet.
SensorEvent Klasse Wird vom System für die Veröffentlichung von Sensordaten verwendet. Hierzu gehören die Sensorwerte (im Rohformat), der Sensortyp, die Datengenauigkeit und ein Zeitstempel.
SensorEventListener Klasse Bietet Callbackmethoden, um Benachrichtigungen vom SensorManager zu empfangen, wenn sich die Sensordaten oder die Sensorgenauigkeit geändert haben.

 

2.2 Ermitteln der Sensorkonfiguration

Die Entscheidung, welche Sensoren auf einem Gerät verfügbar sind, liegt ausschließlich beim Gerätehersteller. Mit dem Sensor-Framework lassen sich zur Laufzeit alle verfügbaren Sensoren ermitteln. Hierzu wird die SensorManager-Methode getSensorList() mit dem Parameter Sensor.TYPE_ALL aufgerufen. Der folgende Code zeigt eine Liste der verfügbaren Sensoren an sowie Informationen zum Hersteller, der Leistungsaufnahme und der Genauigkeit für jeden Sensor auf einem Fragment:

Code-Beispiel 2-1 Ein Fragment, das die Liste der Sensoren anzeigt (**)

2.3 Sensorkoordinatensystem

Das Sensor-Framework meldet Sensordaten anhand eines dreiachsigen Standardkoordinatensystems, wobei X, Y und Z jeweils durch die Werte values[0], values[1] und values[2] im Objekt SensorEvent angegeben sind.

Einige Sensoren (wie Licht-, Temperatur- oder Näherungssensoren) geben nur einen Wert zurück. Bei diesen Sensoren wird im Objekt SensorEvent nur values[0] verwendet.

Andere Sensoren melden Daten im dreiachsigen Standardkoordinatensystem. Zu diesen Sensoren gehören:

  • Beschleunigungssensor
  • Gravitationssensor
  • Gyroskop
  • Magnetfeldsensor

Das dreiachsige Sensorkoordinatensystem ist relativ zur natürlichen (Standard-)Ausrichtung des Gerätedisplays definiert. Bei Tablets ist die natürliche Ausrichtung in der Regel das Querformat, bei Smartphones hingegen das Hochformat. Befindet sich ein Gerät in seiner natürlichen Ausrichtung, so ist die X-Achse horizontal und zeigt nach rechts, die Y-Achse ist vertikal und zeigt nach oben und die Z-Achse zeigt vorne (aus dem Display) heraus. Das folgende Diagramm zeigt das Sensorkoordinatensystem für ein Tablet:


Abb. 2-1 Das Sensorkoordinatensystem

Der wichtigste Aspekt des Sensorkoordinatensystems besteht darin, dass sich das Sensorkoordinatensystem bei Bewegungen des Geräts oder Änderungen der Ausrichtung niemals ändert.

2.4 Überwachung von Sensorereignissen

Das Sensor-Framework meldet Sensordaten über SensorEvent-Objekte. Eine Klasse kann die Daten eines bestimmten Sensors überwachen, indem die SensorEventListener-Schnittstelle implementiert wird und beim SensorManager die Registrierung für den entsprechenden Sensor erfolgt. Das Sensor-Framework informiert die Klasse über Änderungen des Sensorzustands anhand der beiden folgenden – durch die Klasse implementierten – SensorEventListener-Callbackmethoden:

onAccuracyChanged()

und

onSensorChanged()

Der folgende Code implementiert den SensorDialog, den wir im SensorInfoFragment-Beispiel in Abschnitt 2.2 verwendet haben.

package com.intel.deviceinfo;
 
import android.app.Dialog;
import android.content.Context;
import android.hardware.Sensor;
import android.hardware.SensorEvent;
import android.hardware.SensorEventListener;
import android.hardware.SensorManager;
import android.os.Bundle;
import android.widget.TextView;
 
public class SensorDialog extends Dialog implements SensorEventListener {
    Sensor mSensor;
    TextView mDataTxt;
    private SensorManager mSensorManager;
     
 
    public SensorDialog(Context ctx, Sensor sensor) {
        this(ctx);
        mSensor = sensor;
    }
     
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        mDataTxt = (TextView) findViewById(R.id.sensorDataTxt);
        mDataTxt.setText("...");
        setTitle(mSensor.getName());
    }
     
    @Override
    protected void onStart() {
        super.onStart();
        mSensorManager.registerListener(this, mSensor,  SensorManager.SENSOR_DELAY_FASTEST);
    }
         
    @Override
    protected void onStop() {
        super.onStop();
        mSensorManager.unregisterListener(this, mSensor);
    }
 
    @Override
    public void onAccuracyChanged(Sensor sensor, int accuracy) {
    }
 
    @Override
    public void onSensorChanged(SensorEvent event) {
        if (event.sensor.getType() != mSensor.getType()) {
            return;
        }
        StringBuilder dataStrBuilder = new StringBuilder();
        if ((event.sensor.getType() == Sensor.TYPE_LIGHT)||
            (event.sensor.getType() == Sensor.TYPE_TEMPERATURE)) {
            dataStrBuilder.append(String.format("Data: %.3fn", event.values[0]));
        }
        else{         
            dataStrBuilder.append( 
                String.format("Data: %.3f, %.3f, %.3fn", 
                event.values[0], event.values[1], event.values[2] ));
        }
        mDataTxt.setText(dataStrBuilder.toString());
    }
}

Code-Beispiel 2-2 Ein Dialog, der die Sensorwerte anzeigt (**)

2.5 Bewegungssensoren

Mit Bewegungssensoren werden Gerätebewegungen überwacht, beispielsweise Schütteln, Drehen, Schwenken oder Neigen. Zwei auf vielen Tablets und Smartphones integrierte Bewegungssensoren sind der Beschleunigungsmesser und das Gyroskop.

Bewegungssensoren melden Daten über das Sensorkoordinatensystem mit 3 Werten im Objekt SensorEvent, wobei values[0], values[1] und values[2] jeweils für Werte der X-, Y- und Z-Achse stehen.

Um die Bewegungssensoren und den Einsatz der Daten in einer Anwendung zu verstehen, müssen wir einige Physikformeln anwenden, und zwar in Bezug auf Kraft, Masse, Beschleunigung und die zeitliche Beziehung mehrerer dieser Komponenten sowie die newtonschen Bewegungsgesetze. Weitere Informationen zu diesen Formeln und Beziehungen können Sie in Physiklehrbüchern oder anderen öffentlich zugänglichen Quellen nachlesen.

2.5.1 Beschleunigungssensor

Der Beschleunigungssensor misst die Beschleunigung, der das Gerät ausgesetzt ist.

Tabelle 2-2 Der Beschleunigungssensor

Sensor Typ SensorEvent-Daten (m/s2) Beschreibung
Beschleunigungssensor TYPE_ACCELEROMETER values[0]
values[1]
values[2]
Beschleunigung entlang der X-Achse
Beschleunigung entlang der Y-Achse
Beschleunigung entlang der Z-Achse

Das Konzept des Beschleunigungsmessers beruht auf dem zweiten newtonschen Bewegungsgesetz:

a = F / m

Die Beschleunigung eines Objekts ist das Ergebnis der extern auf das Objekt ausgeübten Kraft. Zu den externen Kräften zählt auch die Kraft, die auf alle Objekte auf der Erde einwirkt: die Schwerkraft. Sie ist proportional zu der auf das Objekt ausgeübten Kraft F und umgekehrt proportional zur Masse m des Objekts.

In unserem Code wird die Gleichung oben nicht direkt angewendet. Uns interessiert normalerweise, wie sich die Beschleunigung innerhalb eines bestimmten Zeitraums auf die Geschwindigkeit und Position des Geräts auswirkt. Die folgende Gleichung beschreibt die Beziehung zwischen der Geschwindigkeit eines Objekts (v1), seiner Ausgangsgeschwindigkeit (v0), der Beschleunigung (a) und der Zeit (t):

v1 = v0 + at

Mit der folgenden Gleichung lässt sich die Positionsveränderung s des Objekts berechnen:

s = v0t + (1/2)at2

Oftmals wird mit der Bedingung v0 = 0 begonnen (bevor sich die Position des Geräts verändert), was die Gleichung wie folgt vereinfacht:

s = at2/2

Aufgrund der Schwerkraft ist jedes Objekt auf der Erde der Erdbeschleunigung (gekennzeichnet durch g) ausgesetzt. Unabhängig von der Masse des Objekts hängt g lediglich vom Breitengrad der Objektposition ab und wird durch einen Wert im Bereich zwischen 9,78 und 9,82 (m/s2) bestimmt. Wir verwenden für g einen gängigen Standardwert:

g = 9,80665 (m/s2)

Da der Beschleunigungsmesser die Werte anhand eines mehrdimensionalen Gerätekoordinatensystems zurückgibt, können wir in unserem Code mit den folgenden Gleichungen die Abstände entlang der X-, Y- und Z-Achse berechnen:

Sx = AxT2/2

Sy = AyT2/2

Sz = AzT2/2

Sx, Sy und Sz entsprechen den Positionsveränderungen auf der X-, Y- und Z-Achse; und Ax, Ay und Az der jeweiligen Beschleunigung auf der X-, Y- und Z-Achse. T bezeichnet die Messdauer.

Der folgende Code zeigt die Instanziierung eines Beschleunigungsmessers:

public class SensorDialog extends Dialog implements SensorEventListener {
    …   
    private Sensor mSensor;
    private SensorManager mSensorManager;
     
    public SensorDialog(Context context) {
        super(context);
        mSensorManager = (SensorManager)context.getSystemService(Context.SENSOR_SERVICE);
        mSensor = mSensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);
    …
}

Code-Beispiel 2-3 Instanziierung eines Beschleunigungsmessers (**)

Bisweilen werden nicht alle drei Dimensionen verwendet. Und bisweilen muss auch die Ausrichtung des Geräts berücksichtigt werden. Beispiel: Wenn wir eine „Labyrinth“-Anwendung entwickeln, verwenden wir ausschließlich die Erdbeschleunigung auf der X- und Y-Achse zur Berechnung der Bewegungsrichtung der Kugel und der Abstände basierend auf der Ausrichtung des Geräts. Das folgende Codefragment verdeutlicht die Logik:

@Override
public void onSensorChanged(SensorEvent event) {
    if (event.sensor.getType() != Sensor.TYPE_ACCELEROMETER) {
        return;
    } 
float accelX, accelY;
…
//detect the current rotation currentRotation from its “natural orientation”
//using the WindowManager
    switch (currentRotation) {
        case Surface.ROTATION_0:
            accelX = event.values[0];
            accelY = event.values[1];
            break;
        case Surface.ROTATION_90:
            accelX = -event.values[0];
            accelY = event.values[1];
            break;
        case Surface.ROTATION_180:
            accelX = -event.values[0];
            accelY = -event.values[1];
            break;
        case Surface.ROTATION_270:
            accelX = event.values[0];
            accelY = -event.values[1];
            break;
    }
    //calculate the ball’s moving distances along x, and y using accelX, accelY and the time delta
        …
    }
}

Code-Beispiel 2-4 Berücksichtigung der Ausrichtung des Geräts bei Verwendung der Beschleunigungssensordaten in einem Labyrinth-Spiel (**)

2.5.2 Gyroskop (Kreiselsensor)

Das Gyroskop (Kurzform: Gyro) misst die Drehrate des Geräts um die X-, Y- und Z-Achse. Die vom Gyroskop ermittelten Datenwerte können positiv oder negativ sein. Betrachtet man den Ausgangspunkt von einer Position entlang der positiven Achshälfte und erfolgt die Drehung um die Achse gegen den Uhrzeigersinn, so ist der Wert positiv. Erfolgt die Drehung um die Achse hingegen im Uhrzeigersinn, so ist der Wert negativ. Die Richtung eines Gyroskopwerts lässt sich auch anhand der „Rechte-Hand-Regel“ bestimmen:


Abb. 2-2 Ermittlung der positiven Drehrichtung anhand der „Rechte-Hand-Regel“

Tabelle 2-3 Das Gyroskop

Sensor Typ SensorEvent-Daten (rad/s) Beschreibung
Gyroskop TYPE_GYROSCOPE values[0]
values[1]
values[2]
Drehrate um die X-Achse
Drehrate um die Y-Achse
Drehrate um die Z-Achse

 

Der folgende Code zeigt die Instanziierung eines Gyroskops:

public class SensorDialog extends Dialog implements SensorEventListener {
    …   
    private Sensor mGyro;
    private SensorManager mSensorManager;
     
    public SensorDialog(Context context) {
        super(context);
        mSensorManager = (SensorManager)context.getSystemService(Context.SENSOR_SERVICE);
        mGyro = mSensorManager.getDefaultSensor(Sensor.TYPE_GYROSCOPE);
    …
}

Code-Beispiel 2-5 Instanziierung eines Gyroskops (**)

2.6 Positionssensoren

Viele Android-Tablets unterstützen zwei Positionssensoren: ein Magnetometer und einen Näherungssensor. Das Magnetometer misst die Erdmagnetfeldstärke entlang der X-, Y- und Z-Achse. Der Näherungssensor erkennt den Abstand des Geräts zu einem anderen Objekt.

2.6.1 Magnetometer

In einem Android*-System kommt das Magnetometer hauptsächlich für die Kompassfunktion zum Einsatz.

Sensor Typ SensorEvent-Daten (µT) Beschreibung
Magnetometer TYPE_MAGNETIC_FIELD values[0]
values[1]
values[2]
Erdmagnetfeldstärke entlang der X-Achse
Erdmagnetfeldstärke entlang der Y-Achse
Erdmagnetfeldstärke entlang der Z-Achse

 

Das folgende Beispiel zeigt die Instanziierung eines Magnetometers:

public class SensorDialog extends Dialog implements SensorEventListener {
    …   
    private Sensor mMagnetometer;
    private SensorManager mSensorManager;
     
    public SensorDialog(Context context) {
        super(context);
        mSensorManager = (SensorManager)context.getSystemService(Context.SENSOR_SERVICE);
        mMagnetometer = mSensorManager.getDefaultSensor(Sensor.TYPE_MAGNETIC_FIELD);
    …
}

Code-Beispiel 2-6 Instanziierung eines Magnetometers (**)

2.6.2 Näherungssensor

Der Näherungssensor ermittelt den Abstand zwischen dem Gerät und einem anderen Objekt. Das Gerät kann damit erkennen, ob es nahe am Benutzer gehalten wird, und daraus zum Beispiel schließen, ob der Benutzer gerade telefoniert.

Sensor Typ SensorEvent-Daten Beschreibung
Näherungssensor TYPE_PROXIMITY values[0] Abstand von einem Objekt in cm. Einige Abstandssensoren melden nur anhand eines booleschen Werts, ob das Objekt nahe genug ist.

 

Der folgende Code zeigt die Instanziierung eines Näherungssensors:

public class SensorDialog extends Dialog implements SensorEventListener {
    …   
    private Sensor mProximity;
    private SensorManager mSensorManager;
     
    public SensorDialog(Context context) {
        super(context);
        mSensorManager = (SensorManager)context.getSystemService(Context.SENSOR_SERVICE);
        mProximity = mSensorManager.getDefaultSensor(Sensor.TYPE_PROXIMITY);
    …
}

Code-Beispiel 2-7 Instanziierung eines Näherungssensors (**)

2.7 Umgebungssensoren

Die Umgebungssensoren erkennen und melden Umgebungsparameter des Geräts, wie Licht, Temperatur, Druck oder Luftfeuchtigkeit. Die Entscheidung, welche Sensoren auf einem Gerät verfügbar sind, liegt ausschließlich beim Gerätehersteller. Der Umgebungslichtsensor (in Englisch: Ambient Light Sensor, ALS) ist auf zahlreichen Android*-Tablets verfügbar.

2.7.1 Umgebungslichtsensor (ALS)

Mit dem Umgebungslichtsensor ermittelt das System die Lichtstärke in der Umgebung und kann damit die Bildschirmhelligkeit automatisch anpassen.

Sensor Typ SensorEvent-Daten (lx) Beschreibung
Umgebungslichtsensor (ALS) TYPE_LIGHT values[0] Die Lichtstärke in der Umgebung des Geräts

 

Der folgende Code zeigt die Instanziierung des ALS:

…   
private Sensor mALS;
private SensorManager mSensorManager;
 
…   
    mSensorManager = (SensorManager)context.getSystemService(Context.SENSOR_SERVICE);
    mALS = mSensorManager.getDefaultSensor(Sensor.TYPE_LIGHT);
…

Code-Beispiel 2-8 Instanziierung eines Umgebungslichtsensors (**)

2.8 Richtlinien für die Sensorleistung und Optimierung

Wenn Sie in Ihren Anwendungen Sensoren verwenden wollen, sollten Sie diese bewährten Verfahren befolgen:

  • Prüfen Sie stets, ob der gewünschte Sensor verfügbar ist, bevor Sie ihn verwenden.
    Die Android*-Plattform erfordert auf einem Gerät weder die Implementierung, noch den Ausschluss bestimmter Sensoren. Über die Sensorkonfiguration entscheidet einzig und allein der Gerätehersteller. Bevor Sie einen Sensor in Ihrer Anwendung verwenden, überprüfen Sie, ob er auch tatsächlich verfügbar ist.
  • Melden Sie die Sensor-Listener stets ab.
    Wenn die Aktivität, die den Sensor-Listener implementiert, unsichtbar wird oder der Dialog stoppt, melden Sie den Sensor-Listener ab. Hierzu kann die onPause()-Methode der Aktivität oder die onStop()-Methode des Dialogs verwendet werden. Andernfalls setzt der Sensor die Datenerfassung fort, was Akkuenergie benötigt.
  • Blockieren Sie niemals die onSensorChanged()-Methode.
    Die Methode onSensorChanged() wird regelmäßig vom System aufgerufen, um die Sensordaten zu melden. Diese Methode sollte so wenig so wenig Logik wie möglich enthalten. Komplizierte Sensordatenberechnungen sollten außerhalb dieser Methode stattfinden.
  • Testen Sie Sensoranwendungen stets auf echten Geräten.
    Alle in diesem Abschnitt beschriebenen Sensoren sind Hardwaresensoren. Der Android-Emulator ist eventuell nicht ausreichend geeignet, um die Funktion und Leistung eines Sensors zu simulieren.

3 GPS und Position

GPS (Global Positioning System) liefert anhand von Satellitensignalen weltweit präzise Daten zur geografischen Position. GPS ist auf vielen Android*-Tablets verfügbar. GPS verhält sich in vielerlei Hinsicht wie ein Positionssensor. Es kann Anwendungen, die auf dem Gerät laufen, mit präzisen Positionsdaten versorgen. GPS wird auf der Android*-Plattform nicht direkt vom Sensor-Framework verwaltet. Vielmehr greift der Android*-Standortdienst auf die GPS-Daten zu und leitet sie mittels Location-Listener-Callbacks an die Anwendung weiter.

3.1 Android*-Standortdienste

Sensor Typ Beschreibung
LocationManager Klasse Wird für den Zugriff auf die Standortdienste verwendet. Bietet verschiedene Methoden zur Anforderung regelmäßiger Standortupdates für eine Anwendung oder zum Senden von Näherungswarnungen.
LocationProvider Abstract-Klasse Die abstract-Superklasse für Location-Provider
Position Klasse Wird von Location-Providern zur Einkapselung geografischer Daten verwendet
LocationListener Schnittstelle Wird für den Empfang von Positionsmitteilungen vom LocationManager verwendet

 

3.2 Abrufen von GPS-Positionsupdates

Ähnlich wie der Mechanismus, mit dem das Sensor-Framework auf Sensordaten zugreift, implementiert die Anwendung verschiedene in der LocationListener-Schnittstelle definierte Callbackmethoden, um GPS-Positionsupdates zu erhalten. Der LocationManager sendet über diese Callbacks GPS-Update-Benachrichtigungen an die Anwendung (Hollywood-Prinzip: „Rufen Sie uns nicht an, wir rufen Sie an.“).

Um in der Anwendung auf GPS-Positionsdaten zuzugreifen, müssen Sie in Ihrer Android*-Manifestdatei die Berechtigung „access fine location“ anfordern:

< manifest … >
…
    < uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
…  
< /manifest >

Code-Beispiel 3-1 Anfordern der Berechtigung „access fine location“ in der Manifestdatei (**)

Der folgende Beispiel-Code zeigt, wie Sie GPS-Updates abrufen und die Breiten- und Längenkoordinaten in einer Dialogtextansicht ausgeben können:

package com.intel.deviceinfo;
 
import android.app.Dialog;
import android.content.Context;
import android.location.Location;
import android.location.LocationListener;
import android.location.LocationManager;
import android.os.Bundle;
import android.widget.TextView;
 
public class GpsDialog extends Dialog implements LocationListener {
    TextView mDataTxt;
    private LocationManager mLocationManager;
     
    public GpsDialog(Context context) {
        super(context);
        mLocationManager = (LocationManager)context.getSystemService(Context.LOCATION_SERVICE);
    }
 
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
           mDataTxt = (TextView) findViewById(R.id.sensorDataTxt);
          mDataTxt.setText("...");
         
        setTitle("Gps Data");
    }
     
    @Override
    protected void onStart() {
        super.onStart();
        mLocationManager.requestLocationUpdates(
            LocationManager.GPS_PROVIDER, 0, 0, this);
    }
         
    @Override
    protected void onStop() {
        super.onStop();
        mLocationManager.removeUpdates(this);
        }
 
    @Override
    public void onStatusChanged(String provider, int status, 
        Bundle extras) {
    }
 
    @Override
    public void onProviderEnabled(String provider) {
    }
 
    @Override
    public void onProviderDisabled(String provider) {
    }
 
    @Override
    public void onLocationChanged(Location location) {
        StringBuilder dataStrBuilder = new StringBuilder();
        dataStrBuilder.append(String.format("Latitude: %.3f,   Logitude%.3fn", location.getLatitude(), location.getLongitude()));
        mDataTxt.setText(dataStrBuilder.toString());
         
    }
}

Code-Beispiel 3-2 Ein Dialog, der GPS-Positionsdaten anzeigt (**)

3.3 Richtlinien für die GPS- und Positionsleistung und Optimierung

GPS liefert die genausten Positionsdaten auf dem Gerät. Andererseits handelt es sich um eine Hardwarefunktion, die zusätzlichen Strom verbraucht. Zudem benötigt GPS für die erste Positionsbestimmung einige Zeit. Für die Entwicklung von Anwendungen mit GPS- und ortsbezogenen Funktionen sollten Sie die folgenden Richtlinien befolgen:

  • Ziehen Sie alle verfügbaren Location-Provider in Betracht.
    Neben GPS_PROVIDER gibt es auch NETWORK_PROVIDER. Falls ungefähre Positionsdaten für Ihre Anwendung ausreichen, bietet sich auch NETWORK_PROVIDER an.
  • Verwenden Sie die Positionsdaten im Zwischenspeicher.
    GPS benötigt für die erste Positionsbestimmung einige Zeit. Während Ihre Anwendung auf ein genaues GPS-Positionsupdate wartet, können Sie einen Teil der Arbeit erledigen, indem Sie zunächst die Methode getlastKnownLocation() des LocationManager verwenden.
  • Reduzieren Sie die Häufigkeit und Dauer von Positionsupdate-Anfragen auf ein Minimum.
    Sie sollten Positionsupdates nur bei Bedarf anfordern und die Abmeldung vom Location-Manager sofort durchführen, wenn Sie keine Positionsupdates mehr benötigen.

4 Zusammenfassung

Die Android*-Plattform bietet APIs, über die Entwickler auf die eingebauten Gerätesensoren zugreifen können. Diese Sensoren können höchst präzise Rohdaten über die aktuelle Bewegung, den Standort und die Umgebungsbedingungen des Geräts liefern. Bei der Entwicklung von Sensoranwendungen sollten Sie für beste Leistung und Energieeffizienz bewährte Verfahren befolgen.

Danksagung

Der Autor dankt seinem Kollegen Nathan Totura für den Quellcode, der in den Beispielen dieser Anleitung verwendet wurde.

Über den Autor

Miao Wei arbeitet bei Intel als Software-Engineer in der Software and Services Group.

Hinweise

DIE INFORMATIONEN IN DIESEM DOKUMENT WERDEN IN ZUSAMMENHANG MIT INTEL® PRODUKTEN BEREITGESTELLT. DURCH DIESES DOKUMENT WERDEN WEDER AUSDRÜCKLICH NOCH KONKLUDENT ODER AUF ANDERE WEISE IRGENDWELCHE RECHTE AN GEISTIGEM EIGENTUM GEWÄHRT. MIT AUSNAHME DER FÜR DEN VERKAUF DIESER PRODUKTE IN DEN GESCHÄFTSBEDINGUNGEN VON INTEL DARGELEGTEN ANGABEN ÜBERNIMMT INTEL KEINE HAFTUNG. INTEL SCHLIESST IM ZUSAMMENHANG MIT DEM VERKAUF UND/ODER DER VERWENDUNG VON INTEL® PRODUKTEN JEDE AUSDRÜCKLICHE ODER STILLSCHWEIGENDE HAFTUNG ODER GARANTIE AUS, EINSCHLIESSLICH DER HAFTUNG BZW. GARANTIE IN BEZUG AUF DIE EIGNUNG FÜR EINEN BESTIMMTEN ZWECK, DIE HANDELSÜBLICHKEIT ODER DIE VERLETZUNG VON PATENTEN, URHEBERRECHTEN ODER ANDEREN RECHTEN AUF GEISTIGES EIGENTUM.

SOFERN NICHT ANDERWEITIG VON INTEL SCHRIFTLICH BESTÄTIGT, SIND DIE INTEL PRODUKTE NICHT FÜR ANWENDUNGEN KONZIPIERT ODER VORGESEHEN, BEI DENEN SITUATIONEN MIT MÖGLICHEN KÖRPERVERLETZUNGEN ODER VERLETZUNGEN MIT TODESFOLGE AUFTRETEN KÖNNTEN.

Intel behält sich das Recht vor, Spezifikationen und Produktbeschreibungen jederzeit ohne vorherige Ankündigung zu ändern. Entwickler dürfen nicht vom Vorhandensein oder Nichtvorhandensein bestimmter Funktionsmerkmale oder Produkteigenschaften, die als „reserved“ oder als „undefined“ gekennzeichnet sind, ausgehen. Intel behält sich eine künftige Definition derselben vor und lehnt jegliche Haftung hinsichtlich Inkompatibilität bzw. anderer Konflikte, die sich aus künftigen Änderungen dieser Merkmale ergeben, ab. Die hier angegebene Information kann sich jederzeit ohne besondere Mitteilung ändern. Nutzen Sie diese Angaben nicht für die Fertigstellung von Designs.

Die in diesem Dokument beschriebenen Produkte können konstruktionsbedingte Defekte oder Fehler (Errata) enthalten, die zu Abweichungen der Produkteigenschaften von den angegebenen Spezifikationen führen. Eine Liste derzeit bekannter Errata ist auf Anfrage erhältlich.

Wenden Sie sich an Ihr zuständiges Vertriebsbüro von Intel oder an Ihren Distributor, um die neuesten Spezifikationen zu erhalten, bevor Sie Produkte bestellen.

Dokumente, die eine Bestellnummer haben, auf die in diesem Dokument verwiesen wird, sowie andere Literatur von Intel erhalten Sie im Internet
unter: http://www.intel.com/design/literature.htm

Intel und das Intel-Logo sind Marken der Intel Corporation in den USA und anderen Ländern.

*Andere Marken oder Produktnamen sind Eigentum der jeweiligen Inhaber.

**Diese Quellcode-Beispiele werden unter dem Intel Lizenzvertrag für Quellcode-Beispiele veröffentlicht.

Copyright© 2012 Intel Corporation. Alle Rechte vorbehalten.