Sensors API: wat is het, typen sensoren en werken met sensoren

Auteur: IT Sectr Gepubliceerd: 2026-03-26 Leestijd: 10 min

Sensors API — is de interface van het Android-platform voor toegang tot de hardware-sensoren van het apparaat. De API biedt een uniforme manier om gegevens te verkrijgen van de accelerometer, gyroscoop, magnetometer, lichtsensor en andere sensoren. Volgens Google, 2026 is meer dan 95% van de moderne Android-apparaten uitgerust met ten minste drie soorten sensoren, wat brede mogelijkheden biedt voor het ontwikkelen van contextafhankelijke applicaties.

Belangrijkste punten

  • Sensors API — uniforme Android-interface voor het werken met de hardware-sensoren van het apparaat.
  • Drie categorieën — Motion-, Position- en Environment-sensoren met verschillende meetprincipes.
  • SensorManager — systeemservice voor het verkrijgen van de lijst met sensoren en het registreren van listeners.
  • Vernieuwingsfrequentie wordt ingesteld via SENSOR_DELAY-constanten van NORMAL tot FASTEST.
  • Virtuele sensoren — Gravity, Rotation Vector en Linear Acceleration gebaseerd op combinatie van fysieke sensoren.

Wat is Sensors API in Android?

Sensors API — is de programmeerinterface van het Android Framework, die ontwikkelaars toegang geeft tot de hardware-sensoren van het mobiele apparaat. De API maakt deel uit van de Android SDK sinds versie 1.0 en is toegankelijk via het pakket android.hardware. De interface abstraheert de verschillen tussen sensorimplementaties van verschillende fabrikanten — Qualcomm, MediaTek, Samsung Exynos — en biedt een uniform model voor het werken met sensoren.

Belangrijkste mogelijkheden van Sensors API

De API maakt drie kernoperaties mogelijk: het verkrijgen van de lijst met beschikbare sensoren, het registreren van listeners voor het ontvangen van gegevens en het beheren van de frequentie van uitlezingen. SensorManager is het centrale toegangspunt voor alle operaties. Het systeem meldt de applicatie via de callback onSensorChanged door een SensorEvent-object met een array van float-waarden door te geven.

Evolutie van Sensors API

Gedurende het bestaan van Android heeft de API verschillende ontwikkelingsfasen doorgemaakt. In versie 2.3 (Gingerbread) kwam ondersteuning voor Batch Processing — het groeperen van sensorgebeurtenissen om energieverbruik te verminderen. Android 4.0 (Ice Cream Sandwich) voegde virtuele sensoren Gravity en Linear Acceleration toe. Vanaf Android 8.0 beperkte het systeem de achtergrondtoegang tot sensoren voor meer privacy.

kotlin
val sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager
val sensorList: List<Sensor> = sensorManager.getSensorList(Sensor.TYPE_ALL)
sensorList.forEach { sensor ->
    Log.d("Sensoren", "${sensor.name} — ${sensor.type}")
}

Beperkingen en vereisten

Niet alle apparaten hebben dezelfde set sensoren. De applicatie moet de beschikbaarheid van een specifieke sensor controleren voordat een listener wordt geregistreerd. De Android-emulator ondersteunt slechts een beperkte set sensoren — accelerometer en magnetometer. Voor het testen van de overige sensoren is een fysiek apparaat nodig. Vanaf Android 12 moeten applicaties het gebruik van sensoren in het manifest declareren.

Soorten Android-sensoren: Motion, Position, Environment

Android classificeert alle sensoren in drie categorieën: Motion (beweging), Position (positie) en Environment (omgeving). Motion-sensoren omvatten accelerometer, gyroscoop en stappenteller. Position-sensoren bevatten magnetometer en Orientation. Environment — lichtsensor, druk, temperatuur en vochtigheid.

CategorieSensorenType (constante)Fysiek/Virtueel
MotionAccelerometerTYPE_ACCELEROMETERFysiek
MotionGyroscoopTYPE_GYROSCOPEFysiek
MotionStappentellerTYPE_STEP_COUNTERFysiek
MotionGravityTYPE_GRAVITYVirtueel
PositionMagnetometerTYPE_MAGNETIC_FIELDFysiek
PositionRotation VectorTYPE_ROTATION_VECTORVirtueel
EnvironmentLichtTYPE_LIGHTFysiek
EnvironmentDrukTYPE_PRESSUREFysiek

Motion-sensoren: accelerometer en gyroscoop

De accelerometer meet versnelling in m/s² langs drie assen — X, Y en Z. Waarden omvatten zwaartekracht (9.8 m/s² op de Z-as in rust). De gyroscoop meet de hoeksnelheid in rad/s — de rotatiesnelheid van het apparaat rond elke as. De combinatie van deze twee sensoren wordt gebruikt in navigatie, games en AR-applicaties.

kotlin
class SensorActivity : Activity(), SensorEventListener {
    override fun onSensorChanged(event: SensorEvent) {
        if (event.sensor.type == Sensor.TYPE_ACCELEROMETER) {
            val x = event.values[0]
            val y = event.values[1]
            val z = event.values[2]
            textView.text = "X: $x, Y: $y, Z: $z"
        }
    }
    override fun onAccuracyChanged(sensor: Sensor, accuracy: Int) {}
}

Position-sensoren: magnetometer en oriëntatie

De magnetometer (TYPE_MAGNETIC_FIELD) meet het magnetisch veld in microtesla (µT) langs drie assen. Het wordt gebruikt als digitaal kompas — in combinatie met de accelerometer kan het azimut van het apparaat worden bepaald. Rotation Vector — een virtuele sensor die gegevens van gyroscoop, accelerometer en magnetometer combineert voor nauwkeurige oriëntatiebepaling.

Environment-sensoren: licht, druk, temperatuur

De lichtsensor (TYPE_LIGHT) meet het externe verlichtingsniveau in lux (lx). Het wordt gebruikt voor automatische aanpassing van de schermhelderheid. De druksensor (TYPE_PRESSURE) meet de atmosferische druk in hectopascal (hPa) — wordt gebruikt in navigatie-apps om de hoogte boven zeeniveau te bepalen.

Hoe werkt de architectuur van Sensors API

Sensors API is gebouwd op een client-server architectuur. De applicatie fungeert als client, SensorManager als Android-systeemservice. Wanneer de applicatie een listener registreert via registerListener, maakt SensorManager verbinding met HAL (Hardware Abstraction Layer) — de laag-niveau sensor driver die werkt op het niveau van de Linux-kernel.

Levenscyclus van een sensor-gebeurtenis

De HAL-driver ontvangt ruwe gegevens van de hardware-chip, filtert ruis en stuurt ze omhoog door de stack — via SensorService (systeemproces) naar de applicatie. Gegevens worden verzonden als een SensorEvent-object met een array van float-waarden values en een tijdstempel in nanoseconden. De frequentie van gebeurtenissen hangt af van de geselecteerde leveringsmodus.

Leveringsmodi voor gebeurtenissen

Bij het registreren van een listener specificeert de ontwikkelaar de gewenste vertraging tussen gebeurtenissen via de constanten SENSOR_DELAY_NORMAL (200 ms), SENSOR_DELAY_UI (60 ms), SENSOR_DELAY_GAME (20 ms) en SENSOR_DELAY_FASTEST (0 ms — maximale frequentie). De werkelijke frequentie kan afwijken — het systeem optimaliseert het energieverbruik.

kotlin
val sensor = sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER)
sensorManager.registerListener(
    this,
    sensor,
    SensorManager.SENSOR_DELAY_GAME
)

Batchverwerking (Batch Processing)

Vanaf Android 2.3 ondersteunen sensoren batchmodus — gebeurtenissen worden verzameld in een FIFO-buffer en in één pakket geleverd. Hierdoor kan de processor langer in slaapmodus blijven, wat het energieverbruik tot 60% vermindert. De buffergrootte is afhankelijk van de sensorchip en staat vermeld in het veld Sensor.fifoMaxEventCount.

SensorManager gebruiken voor toegang tot sensoren

SensorManager — systeemservice toegankelijk via getSystemService(Context.SENSOR_SERVICE). Het biedt methoden voor het verkrijgen van de lijst met sensoren, het verkrijgen van een specifieke standaardsensor en het registreren/opzeggen van listeners. SensorManager — singleton, één instantie voor de hele applicatie.

Beschikbaarheid van sensor controleren

Voordat een sensor wordt gebruikt, moet de aanwezigheid ervan worden gecontroleerd. De methode getDefaultSensor(type) retourneert null als de sensor niet beschikbaar is op het apparaat. Het verkrijgen van null zonder controle leidt tot een NullPointerException bij het registreren van de listener. De lijst van alle sensoren wordt geretourneerd door de methode getSensorList(type).

kotlin
fun checkSensorAvailability(type: Int): Boolean {
    val sensorManager =
        getSystemService(Context.SENSOR_SERVICE) as SensorManager
    return sensorManager.getDefaultSensor(type) != null
}

// Gebruik:
if (checkSensorAvailability(Sensor.TYPE_GYROSCOPE)) {
    Log.d("Sensor", "Gyroscoop beschikbaar")
}

Listener registreren en opzeggen

De listener wordt geregistreerd via registerListener(listener, sensor, delay). Belangrijk: de listener moet worden opgezegd in de methode onPause() via unregisterListener(listener). Als dit niet gebeurt, blijft de applicatie sensor-gebeurtenissen ontvangen, zelfs op de achtergrond, waardoor de batterij leeg raakt. Android 8+ geeft een waarschuwing in logcat over niet-geregistreerde listeners.

Nauwkeurigheidsverandering afhandelen

De methode onAccuracyChanged(sensor, accuracy) wordt aangeroepen bij verandering van de nauwkeurigheid van de sensor. Waarden: SENSOR_STATUS_ACCURACY_HIGH, MEDIUM, LOW en UNRELIABLE. Bij ontvangst van UNRELIABLE moeten sensorgegevens worden genegeerd totdat de nauwkeurigheid is hersteld. De magnetometer vereist bijvoorbeeld kalibratie — het apparaat schudden in de vorm van een acht.

Codevoorbeelden voor werken met sensoren in Kotlin

Laten we praktische voorbeelden bekijken van het gebruik van Sensors API in Android-applicaties in Kotlin. Eerste voorbeeld — bepalen van de schermoriëntatie met behulp van de accelerometer. Tweede — uitlezen van de magnetometer met kalibratie. Derde — stappendetector met behulp van de stappenteller.

Apparaatoriëntatie bepalen

Voor het bepalen van de oriëntatie wordt een combinatie van accelerometer en magnetometer gebruikt. De methode SensorManager.getRotationMatrix() berekent de rotatiematrix, en getOrientation() haalt de hoeken pitch, roll en azimuth eruit. Azimuth (azimut) — de hoek ten opzichte van het magnetische noorden in radialen.

kotlin
val gravity = FloatArray(3)
val geomagnetic = FloatArray(3)
val rotationMatrix = FloatArray(9)
val orientation = FloatArray(3)

SensorManager.getRotationMatrix(
    rotationMatrix, null, gravity, geomagnetic
)
SensorManager.getOrientation(rotationMatrix, orientation)
// orientation[0] — azimuth, [1] — pitch, [2] — roll
val azimuthDeg = Math.toDegrees(orientation[0].toDouble())

Stappendetector met stappenteller

De stappenteller (TYPE_STEP_COUNTER) retourneert het totale aantal stappen dat de gebruiker heeft gezet sinds de laatste herstart van het apparaat. De sensor werkt op hardwareniveau — hij is actief, zelfs wanneer de app niet draait. Om het aantal stappen per sessie te krijgen, moet de beginwaarde worden opgeslagen en het verschil worden berekend.

kotlin
var initialSteps = 0
var isInitialized = false

override fun onSensorChanged(event: SensorEvent) {
    if (event.sensor.type == Sensor.TYPE_STEP_COUNTER) {
        if (!isInitialized) {
            initialSteps = event.values[0].toInt()
            isInitialized = true
        }
        val currentSteps = event.values[0].toInt()
        val sessionSteps = currentSteps - initialSteps
        Log.d("Stappen", "Stappen per sessie: $sessionSteps")
    }
}

Adaptieve helderheid op basis van lichtsensor

De lichtsensor maakt het mogelijk de interface aan te passen aan de omgevingsomstandigheden. Bij weinig licht (minder dan 10 lx) kan worden overgeschakeld naar een donker thema. Bij fel zonlicht (meer dan 10000 lx) — kan het contrast worden verhoogd. Voor het filteren van ruis wordt een voortschrijdend gemiddelde van de laatste 5 waarden gebruikt.

Virtuele sensoren en fusie-algoritmen

Android biedt verschillende virtuele sensoren die geen directe hardware-equivalent hebben. Een virtuele sensor berekent zijn waarden op basis van een combinatie van fysieke sensoren. Dit vermindert de belasting van de ontwikkelaar — het systeem implementeert zelf de datafusie-algoritmen.

Gravity en Linear Acceleration

De Gravity-sensor (TYPE_GRAVITY) haalt de zwaartekrachtcomponent uit de accelerometerwaarden met behulp van een low-pass filter. Linear Acceleration (TYPE_LINEAR_ACCELERATION) — omgekeerd, verwijdert de zwaartekracht en laat alleen de lineaire versnelling van het apparaat over. De som van Gravity en Linear Acceleration geeft de ruwe accelerometerwaarden.

Rotation Vector

Rotation Vector — de meest complexe virtuele sensor. Het combineert gegevens van de gyroscoop (hoogfrequente veranderingen), accelerometer (zwaartekrachtvector) en magnetometer (oriëntatie ten opzichte van het noorden). Het resultaat is een quaternion dat de absolute oriëntatie van het apparaat in de ruimte beschrijft. Wordt gebruikt in AR-applicaties en VR-headsets.

Game Rotation Vector

Game Rotation Vector — een vereenvoudigde versie van Rotation Vector zonder gebruik van de magnetometer. Dit geeft een lagere nauwkeurigheid van de azimutbepaling, maar een hogere vernieuwingsfrequentie en stabiliteit. Aanbevolen voor games waar lage latentie belangrijk is, niet de absolute oriëntatie ten opzichte van het noorden.

Energieverbruik optimaliseren bij het werken met sensoren

Sensoren — een van de meest energie-intensieve componenten van het apparaat. De accelerometer en gyroscoop kunnen bij maximale uitleesfrequentie de batterij in 3–4 uur continu gebruik leegmaken. Het optimaliseren van het werken met sensoren is een kritieke taak voor elke applicatie die Sensors API gebruikt.

Optimale vertraging kiezen

Gebruik SENSOR_DELAY_FASTEST niet zonder noodzaak. Voor UI-animaties is SENSOR_DELAY_UI (60 ms) voldoende. Voor het bepalen van de schermoriëntatie — SENSOR_DELAY_NORMAL (200 ms). Hoe hoger de frequentie, hoe meer tijd de processor in actieve toestand doorbrengt. Het verschil tussen NORMAL en FASTEST is tot 10x in energieverbruik.

Listeners opzeggen op de achtergrond

Vanaf Android 8.0 (API 26) ontvangen achtergrond-applicaties sensor-gebeurtenissen met een verlaagde frequentie. In Android 12+ vereist achtergrondtoegang tot Motion- en Position-sensoren de machtiging BODY_SENSORS_BACKGROUND. Zeg de listenerregistratie op wanneer de app naar de achtergrond gaat — dit verlengt de batterijduur van het apparaat.

Batchverwerking en FIFO-buffer

Gebruik batchverwerking via de methode registerListener(listener, sensor, delay, maxReportLatencyUs). De parameter maxReportLatencyUs specificeert de maximale leveringsvertraging van gebeurtenissen in microseconden. Bij een waarde van 1000000 (1 seconde) worden gebeurtenissen verzameld in de FIFO-buffer van de sensor en eenmaal per seconde geleverd — de processor wordt minder vaak wakker.

Veelgestelde vragen

Welke sensoren zitten op alle Android-apparaten?

De minimale set — accelerometer en magnetometer. Deze twee sensoren zijn aanwezig op meer dan 95% van de apparaten. Gyroscoop, lichtsensor en nabijheidssensor — op 70–80% van de moderne modellen. De overige sensoren (druk, temperatuur, vochtigheid, stappenteller) komen minder vaak voor en zijn afhankelijk van de prijsklasse van het apparaat.

Wat is het verschil tussen TYPE_ACCELEROMETER en TYPE_LINEAR_ACCELERATION?

TYPE_ACCELEROMETER retourneert de volledige versnelling inclusief zwaartekracht (9.8 m/s²). TYPE_LINEAR_ACCELERATION retourneert versnelling zonder zwaartekracht — alleen de versnelling door beweging van het apparaat. Als het apparaat stil ligt, toont de accelerometer 9.8 m/s² op de Z-as, en Linear Acceleration — 0 op alle assen.

Hoe controleer ik of het apparaat de benodigde sensor heeft?

Gebruik getPackageManager().hasSystemFeature() met de bijbehorende constanten: FEATURE_SENSOR_ACCELEROMETER, FEATURE_SENSOR_GYROSCOPE, FEATURE_SENSOR_PROXIMITY en andere. Een alternatieve methode is het aanroepen van getDefaultSensor(type) en het resultaat controleren op null. De eerste methode heeft de voorkeur voor controle in de initialisatiefase.

Waarom springen de sensorwaarden en hoe kan ik ze afvlakken?

Ruwe gegevens van sensoren bevatten ruis. Gebruik voor afvlakking een low-pass filter: newValue = alpha * rawValue + (1 — alpha) * previousValue. Coëfficiënt alpha = 0.1–0.3 geeft een goede balans tussen responsiviteit en gladheid. Voor de gyroscoop wordt ook een high-pass filter toegepast om nuldrift te verwijderen.

Kan ik sensoren op de achtergrond gebruiken?

Ja, maar met beperkingen. Vanaf Android 8.0 wordt de frequentie van sensor-gebeurtenissen verlaagd voor achtergrond-applicaties. Vanaf Android 12 is de machtiging BODY_SENSORS_BACKGROUND vereist voor toegang tot sensoren op de achtergrond. Voor achtergrondwerk wordt het gebruik van een Foreground Service met melding aanbevolen.

Samenvatting

  • Sensors API — uniforme Android-interface voor het verkrijgen van gegevens van hardware-sensoren via SensorManager.
  • Drie categorieën — Motion (accelerometer, gyroscoop), Position (magnetometer) en Environment (licht, druk) met verschillende werkingsprincipes en toepassingen.
  • Virtuele sensoren — Gravity, Linear Acceleration en Rotation Vector gebaseerd op fusie van fysieke sensorgegevens, zonder hardware-equivalent.
  • Optimalisatie — juiste vertraging kiezen (SENSOR_DELAY_NORMAL, UI, GAME, FASTEST) en batchverwerking gebruiken verlaagt energieverbruik tot 60%.
  • Beperkingen — Android 8+ verlaagt sensorfrequentie op de achtergrond, Android 12+ vereist BODY_SENSORS_BACKGROUND voor achtergrondtoegang.
  • Basiscontrole — controleer de aanwezigheid van de sensor via getDefaultSensor of hasSystemFeature voordat u een listener registreert.
  • Gebruik een low-pass filter voor ruisafvlakking en zeg de listenerregistratie op bij achtergrondgang om de batterij te sparen.

We ontwikkelen een mobiele applicatie turnkey

IT Sectr creëert sinds 2017 iOS- en Android-applicaties voor startups en bedrijven. We adviseren u en stellen de beste oplossing voor.

Bespreek het project

Lees ook