Czujniki pozycji

Platforma Android ma dwa czujniki, które pozwalają określić położenie urządzenia: czujnika pola magnetycznego i akcelerometru. Android jest także czujnik, który pozwala określić, jak blisko ścianki urządzenie odnosi się do obiektu (nazywanego czujnikiem zbliżeniowym). czujnik pola geomagnetycznego i czujnik zbliżeniowy są oparte na sprzęcie. Większość Producenci telefonów i tabletów są wyposażone w czujnik pola geomagnetycznego. Podobnie, Producenci telefonów często dołączają czujnik zbliżeniowy, by określić, kiedy telefon jest zbliżony do twarzy użytkownika (na przykład podczas używania telefonu) ). Aby określić orientację urządzenia, możesz skorzystać z odczytów akcelerometr urządzenia i czujnik pola geomagnetycznego.

Uwaga: czujnik orientacji został wycofany w Androidzie 2.2 (poziom interfejsu API 8), a typ czujnika orientacji został wycofany w Androidzie 4.4 W (poziom API 20).

Czujniki pozycji są przydatne do określania fizycznego położenia urządzenia systemu odniesienia. Na przykład możesz użyć pola geomagnetycznego czujnik w połączeniu z akcelerometrem do określania pozycji urządzenia względem magnetycznego bieguna północnego. Możesz również użyć tych czujników do określić orientację urządzenia w punkcie odniesienia aplikacji. Czujniki pozycji nie są zwykle używane do monitorowania ruchu urządzenia, na przykład potrząśnięcia, przechylenia lub ciągu (więcej informacji znajdziesz w artykule Czujniki ruchu).

Czujnik pola geomagnetycznego i akcelerometr zwracają wielowymiarowe macierze wartości z czujnika dla każdego urządzenia SensorEvent. Przykład: czujnik pola geomagnetycznego podaje wartości siły pola geomagnetycznego dla każdej z 3 osi współrzędnych w trakcie pojedynczego zdarzenia czujnika. Podobnie Czujnik akcelerometru mierzy przyspieszenie zdarzenie czujnika. Więcej informacji o używanych układach współrzędnych według czujników, patrz sekcja Układy współrzędnych czujników. Czujnik zbliżeniowy podaje jedną wartość dla każdego zdarzenia czujnika. Tabela 1 zawiera podsumowanie czujników pozycji, które są na platformie Android.

Tabela 1. Czujniki pozycji obsługiwane przez platformę Android.

Czujnik Dane zdarzenia z czujnika Opis Jednostki miary
TYPE_GAME_ROTATION_VECTOR SensorEvent.values[0] Składnik wektora obrotu na osi x (x * sin(Możliwość)). Wielkości bezwymiarowe
SensorEvent.values[1] Składowa wektora obrotu wzdłuż osi y (y * sin(Możliwość kliknięcia/2)).
SensorEvent.values[2] Składowa wektora obrotu wzdłuż osi z (z * sin(Place/2)).
TYPE_GEOMAGNETIC_ROTATION_VECTOR SensorEvent.values[0] Składnik wektora obrotu na osi x (x * sin(Możliwość)). Wielkości bezwymiarowe
SensorEvent.values[1] Składowa wektora obrotu wzdłuż osi y (y * sin(Możliwość kliknięcia/2)).
SensorEvent.values[2] Składowa wektora obrotu wzdłuż osi z (z * sin(Place/2)).
TYPE_MAGNETIC_FIELD SensorEvent.values[0] Siła pola geomagnetycznego na osi x. μT
SensorEvent.values[1] Siła pola geomagnetycznego na osi Y.
SensorEvent.values[2] Siła pola geomagnetycznego na osi Z.
TYPE_MAGNETIC_FIELD_UNCALIBRATED SensorEvent.values[0] Siła pola geomagnetycznego (bez kalibracji twardego żelaza) wzdłuż osi X. μT
SensorEvent.values[1] Siła pola geomagnetycznego (bez kalibracji twardego żelaza) wzdłuż osi Y.
SensorEvent.values[2] Siła pola geomagnetycznego (bez kalibracji twardego żelaza) wzdłuż osi Z.
SensorEvent.values[3] Szacowane odchylenie żelaza na osi X.
SensorEvent.values[4] Szacowane odchylenie żelaza na osi Y.
SensorEvent.values[5] Szacowane odchylenie żelaza na osi Z.
TYPE_ORIENTATION1 SensorEvent.values[0] Azymut (kąt wokół osi Z). Stopnie
SensorEvent.values[1] Wysokość (kąt wokół osi X).
SensorEvent.values[2] Przesunięcie (kąt wokół osi Y).
TYPE_PROXIMITY SensorEvent.values[0] Odległość od obiektu2. cm

1 Ten czujnik został wycofany w Androidzie 2.2 (API poziomu 8), a ten typ czujnika został wycofany w Androidzie 4.4W (poziom API 20). Platforma czujnika zapewnia alternatywne metody wykrywania urządzenia , które są omawiane w kursie Compute od orientacji urządzenia.

2 Niektóre czujniki zbliżeniowe podają tylko wartości binarne co reprezentuję bliższą i daleką odległość.

Użyj czujnika wektorów obrotu gry

Czujnik wektora obrotu gry jest taki sam jak Rotacja czujnika wektorowego, z wyjątkiem, że nie korzysta on z pola geomagnetycznego. Dlatego oś Y nie wskazuje północ, lecz do innego punktu odniesienia. To odwołanie może dryfować o tego samego rządu wielkości, co żyroskop krąży wokół osi Z.

Czujnik wektora obrotu gry nie wykorzystuje pola magnetycznego, dlatego obroty względne są dokładniejsze i nie mają wpływu na zmiany pola magnetycznego. Używaj tego czujnika w grze, jeśli nieważne jest, gdzie jest północ, a normalny wektor obrotu nie odpowiada Twoim potrzebom ponieważ opiera się na polu magnetycznym.

Ten kod pokazuje, jak uzyskać wystąpienie domyślnego wektora obrotu gry czujnik:

Kotlin

private lateinit var sensorManager: SensorManager
private var sensor: Sensor? = null
...
sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager
sensor = sensorManager.getDefaultSensor(Sensor.TYPE_GAME_ROTATION_VECTOR)

Java

private SensorManager sensorManager;
private Sensor sensor;
...
sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
sensor = sensorManager.getDefaultSensor(Sensor.TYPE_GAME_ROTATION_VECTOR);

Użyj czujnika wektora obrotu geomagnetycznego

Geomagnetyczny czujnik wektorowy obrotu jest podobny do czujnika wektora obrotowego, ale nie korzysta z żyroskopu. Dokładność tego czujnika jest mniejsza niż przy normalnym wektorze obrotu ale zużycie energii jest mniejsze. Używaj tego czujnika tylko wtedy, gdy chcesz rejestrować obrót przesyłanie informacji w tle bez nadmiernego zużycia baterii. Ten czujnik jest najbardziej przydatny, gdy jest używany w połączeniu z grupowaniem.

Ten kod pokazuje, jak uzyskać instancję domyślnej obrotu geomagnetycznego czujnik wektorowy:

Kotlin

private lateinit var sensorManager: SensorManager
private var sensor: Sensor? = null
...
sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager
sensor = sensorManager.getDefaultSensor(Sensor.TYPE_GEOMAGNETIC_ROTATION_VECTOR)

Java

private SensorManager sensorManager;
private Sensor sensor;
...
sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
sensor = sensorManager.getDefaultSensor(Sensor.TYPE_GEOMAGNETIC_ROTATION_VECTOR);

Oblicz orientację urządzenia

Obliczając orientację urządzenia, możesz monitorować położenie względem układu odniesienia Ziemi (w szczególności pole magnetyczne bieguna północnego). Ten kod pokazuje, jak obliczyć orientacja:

Kotlin

private lateinit var sensorManager: SensorManager
...
// Rotation matrix based on current readings from accelerometer and magnetometer.
val rotationMatrix = FloatArray(9)
SensorManager.getRotationMatrix(rotationMatrix, null, accelerometerReading, magnetometerReading)

// Express the updated rotation matrix as three orientation angles.
val orientationAngles = FloatArray(3)
SensorManager.getOrientation(rotationMatrix, orientationAngles)

Java

private SensorManager sensorManager;
...
// Rotation matrix based on current readings from accelerometer and magnetometer.
final float[] rotationMatrix = new float[9];
SensorManager.getRotationMatrix(rotationMatrix, null,
    accelerometerReading, magnetometerReading);

// Express the updated rotation matrix as three orientation angles.
final float[] orientationAngles = new float[3];
SensorManager.getOrientation(rotationMatrix, orientationAngles);

System oblicza kąty orientacji przy użyciu właściwości geomagnetycznej urządzenia czujnika terenowego w połączeniu z akcelerometrem urządzenia. Korzystanie z tych 2 funkcji oraz czujniki sprzętowe, system dostarcza dane dotyczące 3 następujących kąty orientacji:

  • Azymut (stopnie obrotu wokół osi -z). To jest kąt między obecnym kierunkiem kompasu urządzenia a północną magnetyczną. Jeśli górna krawędź urządzenia jest skierowana w kierunku północy magnetycznej, azymut wynosi 0. stopnie; jeśli górna krawędź jest skierowana na południe, azymut wynosi 180 stopni. Podobnie jeśli górna krawędź jest skierowana na wschód, azymut wynosi 90 stopni, a górna krawędź jest skierowany na zachód, a azymut wynosi 270 stopni.
  • Pochylenie (stopnie obrotu wokół osi X). To jest kąt między płaszczyzną równoległą do ekranu urządzenia a płaszczyzną równoległą do ziemi. Jeśli trzymasz urządzenie równolegle do ziemi, i przechyl górną krawędź urządzenia w stronę podłogi, kąt nachylenia staje się dodatni. Przechylanie w przeciwnym kierunku: odsunięcie górnej krawędzi urządzenia od ziemi. Powoduje to aby kąt nachylenia był ujemny. Zakres wartości wynosi od -90 stopni do 90 stopni.
  • Obróć (stopnie obrotu wokół osi Y). To jest kąt między płaszczyzną prostopadłą do ekranu urządzenia a płaszczyzną prostopadła do ziemi. Jeśli trzymasz urządzenie równolegle do ziemi przechyl dolną krawędź znajdującą się najbliżej Ciebie i przechyl lewą krawędź urządzenia w kierunku ziemi, kąt obrotu stanie się dodatni. Przechylanie na drugą stronę w kierunku ziemi—przesuwanie prawej krawędzi urządzenia w stronę podłogi powoduje, że kąt obrotu staje się ujemny. Zakres wartości wynosi -180 stopni do 180 stopni.

Uwaga: definicja obrócenia czujnika zmieniła się, aby odzwierciedlała zdecydowana większość wdrożeń w ekosystemie geosensorów.

Zauważ, że kąty te wychodzą z innego układu współrzędnych niż jeden używany w lotnictwie (do odchylenia, rzutu i obrócenia). W systemie lotniczym Oś X jest wzdłuż dłuższej strony płaszczyzny, od ogona do nosa.

Czujnik orientacji pobiera dane przez przetwarzanie nieprzetworzonych danych z czujnika z akcelerometru i czujnika pola geomagnetycznego. Ze względu na duże obciążenie zachodzącego przetwarzania danych, dokładności i precyzji orientacji czujnik jest słaby. Czujnik jest niezawodny tylko wtedy, gdy kąt wynosi 0. Z tego powodu czujnik orientacji został wycofany z Androida. 2.2 (poziom interfejsu API 8) i typ czujnika orientacji został wycofany w Androidzie 4,4 W (poziom interfejsu API 20). Zamiast używać nieprzetworzonych danych z czujnika orientacji, zalecamy użyj funkcji getRotationMatrix() w połączeniu z argumentem Metoda getOrientation() do obliczania wartości orientacji, jak pokazano w tym przykładowym kodzie. W ramach możesz użyć funkcji remapCoordinateSystem() do przełożenia wartości orientacji na ramkę aplikacji odwołania.

Kotlin

class SensorActivity : Activity(), SensorEventListener {

    private lateinit var sensorManager: SensorManager
    private val accelerometerReading = FloatArray(3)
    private val magnetometerReading = FloatArray(3)

    private val rotationMatrix = FloatArray(9)
    private val orientationAngles = FloatArray(3)

    public override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.main)
        sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager
    }

    override fun onAccuracyChanged(sensor: Sensor, accuracy: Int) {
        // Do something here if sensor accuracy changes.
        // You must implement this callback in your code.
    }

    override fun onResume() {
        super.onResume()

        // Get updates from the accelerometer and magnetometer at a constant rate.
        // To make batch operations more efficient and reduce power consumption,
        // provide support for delaying updates to the application.
        //
        // In this example, the sensor reporting delay is small enough such that
        // the application receives an update before the system checks the sensor
        // readings again.
        sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER)?.also { accelerometer ->
            sensorManager.registerListener(
                    this,
                    accelerometer,
                    SensorManager.SENSOR_DELAY_NORMAL,
                    SensorManager.SENSOR_DELAY_UI
            )
        }
        sensorManager.getDefaultSensor(Sensor.TYPE_MAGNETIC_FIELD)?.also { magneticField ->
            sensorManager.registerListener(
                    this,
                    magneticField,
                    SensorManager.SENSOR_DELAY_NORMAL,
                    SensorManager.SENSOR_DELAY_UI
            )
        }
    }

    override fun onPause() {
        super.onPause()

        // Don't receive any more updates from either sensor.
        sensorManager.unregisterListener(this)
    }

    // Get readings from accelerometer and magnetometer. To simplify calculations,
    // consider storing these readings as unit vectors.
    override fun onSensorChanged(event: SensorEvent) {
        if (event.sensor.type == Sensor.TYPE_ACCELEROMETER) {
            System.arraycopy(event.values, 0, accelerometerReading, 0, accelerometerReading.size)
        } else if (event.sensor.type == Sensor.TYPE_MAGNETIC_FIELD) {
            System.arraycopy(event.values, 0, magnetometerReading, 0, magnetometerReading.size)
        }
    }

    // Compute the three orientation angles based on the most recent readings from
    // the device's accelerometer and magnetometer.
    fun updateOrientationAngles() {
        // Update rotation matrix, which is needed to update orientation angles.
        SensorManager.getRotationMatrix(
                rotationMatrix,
                null,
                accelerometerReading,
                magnetometerReading
        )

        // "rotationMatrix" now has up-to-date information.

        SensorManager.getOrientation(rotationMatrix, orientationAngles)

        // "orientationAngles" now has up-to-date information.
    }
}

Java

public class SensorActivity extends Activity implements SensorEventListener {

    private SensorManager sensorManager;
    private final float[] accelerometerReading = new float[3];
    private final float[] magnetometerReading = new float[3];

    private final float[] rotationMatrix = new float[9];
    private final float[] orientationAngles = new float[3];

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
    }

    @Override
    public void onAccuracyChanged(Sensor sensor, int accuracy) {
        // Do something here if sensor accuracy changes.
        // You must implement this callback in your code.
    }

    @Override
    protected void onResume() {
        super.onResume();

        // Get updates from the accelerometer and magnetometer at a constant rate.
        // To make batch operations more efficient and reduce power consumption,
        // provide support for delaying updates to the application.
        //
        // In this example, the sensor reporting delay is small enough such that
        // the application receives an update before the system checks the sensor
        // readings again.
        Sensor accelerometer = sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);
        if (accelerometer != null) {
            sensorManager.registerListener(this, accelerometer,
                SensorManager.SENSOR_DELAY_NORMAL, SensorManager.SENSOR_DELAY_UI);
        }
        Sensor magneticField = sensorManager.getDefaultSensor(Sensor.TYPE_MAGNETIC_FIELD);
        if (magneticField != null) {
            sensorManager.registerListener(this, magneticField,
                SensorManager.SENSOR_DELAY_NORMAL, SensorManager.SENSOR_DELAY_UI);
        }
    }

    @Override
    protected void onPause() {
        super.onPause();

        // Don't receive any more updates from either sensor.
        sensorManager.unregisterListener(this);
    }

    // Get readings from accelerometer and magnetometer. To simplify calculations,
    // consider storing these readings as unit vectors.
    @Override
    public void onSensorChanged(SensorEvent event) {
        if (event.sensor.getType() == Sensor.TYPE_ACCELEROMETER) {
          System.arraycopy(event.values, 0, accelerometerReading,
              0, accelerometerReading.length);
        } else if (event.sensor.getType() == Sensor.TYPE_MAGNETIC_FIELD) {
            System.arraycopy(event.values, 0, magnetometerReading,
                0, magnetometerReading.length);
        }
    }

    // Compute the three orientation angles based on the most recent readings from
    // the device's accelerometer and magnetometer.
    public void updateOrientationAngles() {
        // Update rotation matrix, which is needed to update orientation angles.
        SensorManager.getRotationMatrix(rotationMatrix, null,
            accelerometerReading, magnetometerReading);

        // "rotationMatrix" now has up-to-date information.

        SensorManager.getOrientation(rotationMatrix, orientationAngles);

        // "orientationAngles" now has up-to-date information.
    }
}

Zwykle nie musisz przetwarzać ani filtrować nieprzetworzone kąty orientacji urządzenia inne niż układ współrzędnych do układu odniesienia Twojej aplikacji.

Użyj czujnika pola geomagnetycznego

Czujnik pola geomagnetycznego umożliwia monitorowanie zmian w polu magnetycznym Ziemi. ten kod pokazuje, jak pobrać instancję domyślnego czujnika pola geomagnetycznego:

Kotlin

private lateinit var sensorManager: SensorManager
private var sensor: Sensor? = null
...
sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager
sensor = sensorManager.getDefaultSensor(Sensor.TYPE_MAGNETIC_FIELD)

Java

private SensorManager sensorManager;
private Sensor sensor;
...
sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
sensor = sensorManager.getDefaultSensor(Sensor.TYPE_MAGNETIC_FIELD);

Uwaga: jeśli aplikacja jest kierowana na Androida 12 (poziom interfejsu API 31) lub jest wyższy, ograniczone do stawek.

Czujnik dostarcza nieprzetworzone dane o sile pola (μT) dla każdej z 3 osi współrzędnych. Zwykle nie trzeba bezpośrednio korzystać z czujnika. Zamiast tego możesz użyć wektora obrotu możesz użyć czujnika do określenia nieprzetworzonego ruchu obrotowego. Możesz też skorzystać z akcelerometru i pola geomagnetycznego, czujnik w połączeniu z metodą getRotationMatrix() w celu uzyskania macierzy obrotu i macierzy pochylenia. Następnie możesz: użyj tych macierzy z getOrientation() i getInclination() do uzyskania azymutu i danych o nachyleniu geomagnetycznym.

Uwaga: podczas testowania aplikacji możesz poprawić aby zwiększyć dokładność czujnika przez machanie urządzeniem w kształcie ósemki.

Użyj nieskalibrowanego magnetometru

Nieskalibrowany magnetometr jest podobny do pola geomagnetycznego. , z wyjątkiem pola magnetycznego nie jest kalibrowane. Kalibracja fabryczna i kompensacja temperatury są nadal stosowane do pola magnetycznego. Nieskalibrowany magnetometr przydaje się do obsługi nieprawidłowych szacunków żelaza. Ogólnie rzecz biorąc, geomagneticsensor_event.values[0] będzie blisko uncalibrated_magnetometer_event.values[0] - uncalibrated_magnetometer_event.values[3]. To znaczy,

calibrated_x ~= uncalibrated_x - bias_estimate_x

Uwaga: nieskalibrowane czujniki dają więcej nieprzetworzonych wyników i mogą uwzględnia pewną odchylenie, ale ich pomiary zawierają mniej skoków po korekcie kalibracji. Niektóre aplikacje mogą preferować te nieskalibrowane wyniki jako płynniejsze i bardziej dynamiczne. i niezawodnością. Jeśli na przykład aplikacja próbuje przeprowadzić własną wprowadzanie kalibracji może zniekształcić wyniki.

Oprócz pola magnetycznego nieskalibrowany magnetometr dostarcza szacunkowe odchylenie twardego żelaza na każdej osi. Poniższy kod pokazuje, jak pobrać instancję domyślny nieskalibrowany magnetometr:

Kotlin

private lateinit var sensorManager: SensorManager
private var sensor: Sensor? = null
...
sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager
sensor = sensorManager.getDefaultSensor(Sensor.TYPE_MAGNETIC_FIELD_UNCALIBRATED)

Java

private SensorManager sensorManager;
private Sensor sensor;
...
sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
sensor = sensorManager.getDefaultSensor(Sensor.TYPE_MAGNETIC_FIELD_UNCALIBRATED);

Używaj czujnika zbliżeniowego

Czujnik zbliżeniowy pozwala określić odległość obiektu od urządzenia. Poniżej pokazuje, jak pobrać instancję domyślnego czujnika zbliżeniowego:

Kotlin

private lateinit var sensorManager: SensorManager
private var sensor: Sensor? = null
...
sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager
sensor = sensorManager.getDefaultSensor(Sensor.TYPE_PROXIMITY)

Java

private SensorManager sensorManager;
private Sensor sensor;
...
sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
sensor = sensorManager.getDefaultSensor(Sensor.TYPE_PROXIMITY);

Czujnik zbliżeniowy jest zwykle używany do określania, jak daleko od twarzy osoby znajduje się głowa telefonu (na przykład, gdy użytkownik wykonuje lub odbiera połączenie telefoniczne). Większość czujniki zbliżeniowe zwracają odległość bezwzględną w cm, ale niektóre zwracają dane tylko w pobliżu dalekie wartości.

Uwaga: w niektórych modelach urządzeń czujnik zbliżeniowy znajduje się poniżej ekranu. Gdy jest on włączony, na ekranie może zacząć migać migająca kropka. włącz.

Ten kod pokazuje, jak korzystać z czujnika zbliżeniowego:

Kotlin

class SensorActivity : Activity(), SensorEventListener {

    private lateinit var sensorManager: SensorManager
    private var proximity: Sensor? = null

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

        // Get an instance of the sensor service, and use that to get an instance of
        // a particular sensor.
        sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager
        proximity = sensorManager.getDefaultSensor(Sensor.TYPE_PROXIMITY)
    }

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

    override fun onSensorChanged(event: SensorEvent) {
        val distance = event.values[0]
        // Do something with this sensor data.
    }

    override fun onResume() {
        // Register a listener for the sensor.
        super.onResume()

        proximity?.also { proximity ->
            sensorManager.registerListener(this, proximity, SensorManager.SENSOR_DELAY_NORMAL)
        }
    }

    override fun onPause() {
        // Be sure to unregister the sensor when the activity pauses.
        super.onPause()
        sensorManager.unregisterListener(this)
    }
}

Java

public class SensorActivity extends Activity implements SensorEventListener {
    private SensorManager sensorManager;
    private Sensor proximity;

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

        // Get an instance of the sensor service, and use that to get an instance of
        // a particular sensor.
        sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
        proximity = sensorManager.getDefaultSensor(Sensor.TYPE_PROXIMITY);
    }

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

    @Override
    public final void onSensorChanged(SensorEvent event) {
        float distance = event.values[0];
        // Do something with this sensor data.
    }

    @Override
    protected void onResume() {
        // Register a listener for the sensor.
        super.onResume();
        sensorManager.registerListener(this, proximity, SensorManager.SENSOR_DELAY_NORMAL);
      }

    @Override
    protected void onPause() {
        // Be sure to unregister the sensor when the activity pauses.
        super.onPause();
        sensorManager.unregisterListener(this);
    }
}

Uwaga: niektóre czujniki zbliżeniowe zwracają wartości binarne, które reprezentują „w pobliżu” lub „daleka”. W takim przypadku czujnik zwykle zgłasza swoją wartość maksymalnego zakresu w stanie „dalekim”. i mniejszą wartość w stanie bliskim. Zazwyczaj wartość daleka jest wartością > 5 cm, ale to może być inne od czujnika do czujnika. Maksymalny zasięg czujnika można określić za pomocą metody getMaximumRange().

Warto też przeczytać

Wstecz
Czujniki ruchu
Dalej
Czujniki środowiskowe