Sensors API: mi ez, érzékelők típusai és munka szenzorokkal

Szerző: IT Sectr Megjelenés: 2026-03-26 Olvasási idő: 10 perc

Sensors API — az Android platform interfésze az eszköz hardveres érzékelőinek eléréséhez. Az API egységes módot biztosít az adatok gyűjtésére a gyorsulásmérőtől, giroszkóptól, magnetométertől, fényérzékelőtől és más szenzoroktól. A Google, 2026 adatai szerint a modern Android-eszközök több mint 95%-a legalább három érzékelőtípussal van felszerelve, ami széles lehetőségeket nyit a környezetfüggő alkalmazások fejlesztésére.

Főbb pontok

  • Sensors API — egységes Android interfész az eszköz hardveres érzékelőivel való munkához.
  • Három kategória — Motion, Position és Environment érzékelők eltérő mérési elvekkel.
  • SensorManager — rendszerszolgáltatás az érzékelők listájának lekéréséhez és figyelők regisztrálásához.
  • Frissítési gyakoriság a SENSOR_DELAY konstansokkal állítható be NORMAL-tól FASTEST-ig.
  • Virtuális érzékelők — Gravity, Rotation Vector és Linear Acceleration fizikai érzékelők kombinációján alapulnak.

Mi az a Sensors API Androidban?

Sensors API — az Android Framework programozási interfésze, amely hozzáférést biztosít a fejlesztőknek a mobileszköz hardveres érzékelőihez. Az API az Android SDK része az 1.0 verzió óta, és a android.hardware csomagon keresztül érhető el. Az interfész elvonatkoztatja a különböző gyártók — Qualcomm, MediaTek, Samsung Exynos — érzékelő implementációi közötti különbségeket, és egységes modellt biztosít a szenzorokkal való munkához.

A Sensors API fő képességei

Az API három kulcsfontosságú műveletet tesz lehetővé: az elérhető érzékelők listájának lekérése, figyelők regisztrálása az adatok fogadásához, valamint a leolvasások gyakoriságának kezelése. A SensorManager a központi hozzáférési pont az összes művelethez. A rendszer a onSensorChanged callback-en keresztül értesíti az alkalmazást, átadva egy SensorEvent objektumot float értékek tömbjével.

A Sensors API fejlődése

Az Android fennállása alatt az API több fejlesztési szakaszon ment keresztül. A 2.3 (Gingerbread) verzióban megjelent a Batch Processing támogatása — az érzékelő események csoportosítása az energiafogyasztás csökkentése érdekében. Android 4.0 (Ice Cream Sandwich) hozzáadta a Gravity és Linear Acceleration virtuális érzékelőket. Android 8.0-tól kezdve a rendszer korlátozta a háttérben történő érzékelő hozzáférést az adatvédelem növelése érdekében.

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

Korlátozások és követelmények

Nem minden eszköz rendelkezik azonos érzékelő készlettel. Az alkalmazásnak ellenőriznie kell egy adott érzékelő elérhetőségét a figyelő regisztrálása előtt. Az Android emulátor csak korlátozott érzékelőkészletet támogat — gyorsulásmérőt és magnetométert. A többi érzékelő teszteléséhez fizikai eszköz szükséges. Android 12-től kezdve az alkalmazásoknak deklarálniuk kell az érzékelők használatát a manifestben.

Android érzékelők típusai: Motion, Position, Environment

Az Android minden érzékelőt három kategóriába sorol: Motion (mozgás), Position (helyzet) és Environment (környezet). A Motion érzékelők közé tartozik a gyorsulásmérő, giroszkóp és lépésszámláló. A Position érzékelők tartalmazzák a magnetométert és az Orientation-t. Environment — fényérzékelő, nyomás-, hőmérséklet- és páratartalom-érzékelő.

KategóriaÉrzékelőkTípus (konstans)Fizikai/Virtuális
MotionGyorsulásmérőTYPE_ACCELEROMETERFizikai
MotionGiroszkópTYPE_GYROSCOPEFizikai
MotionLépésszámlálóTYPE_STEP_COUNTERFizikai
MotionGravityTYPE_GRAVITYVirtuális
PositionMagnetométerTYPE_MAGNETIC_FIELDFizikai
PositionRotation VectorTYPE_ROTATION_VECTORVirtuális
EnvironmentFényTYPE_LIGHTFizikai
EnvironmentNyomásTYPE_PRESSUREFizikai

Motion érzékelők: gyorsulásmérő és giroszkóp

A gyorsulásmérő a gyorsulást m/s²-ben méri három tengely mentén — X, Y és Z. Az értékek tartalmazzák a gravitációt (9.8 m/s² a Z tengelyen nyugalmi állapotban). A giroszkóp a szögsebességet méri rad/s-ban — az eszköz forgási sebességét az egyes tengelyek körül. E két érzékelő kombinációját navigációban, játékokban és AR alkalmazásokban használják.

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 érzékelők: magnetométer és tájolás

A magnetométer (TYPE_MAGNETIC_FIELD) a mágneses teret mikroteslában (µT) méri három tengely mentén. Digitális iránytűként használják — a gyorsulásmérővel kombinálva lehetővé teszi az eszköz azimutjának meghatározását. Rotation Vector — egy virtuális érzékelő, amely egyesíti a giroszkóp, gyorsulásmérő és magnetométer adatait a pontos tájolás meghatározásához.

Environment érzékelők: fény, nyomás, hőmérséklet

A fényérzékelő (TYPE_LIGHT) a külső megvilágítás szintjét luxban (lx) méri. A képernyő fényerejének automatikus beállítására használják. A nyomásérzékelő (TYPE_PRESSURE) a légköri nyomást hektopascalban (hPa) méri — navigációs alkalmazásokban használják a tengerszint feletti magasság meghatározására.

Hogyan működik a Sensors API architektúrája

A Sensors API kliens-szerver architektúrára épül. Az alkalmazás kliensként, a SensorManager pedig Android rendszerszolgáltatásként működik. Amikor az alkalmazás regisztrál egy figyelőt a registerListener segítségével, a SensorManager kapcsolódik a HAL-hoz (Hardware Abstraction Layer) — az alacsony szintű érzékelő illesztőprogramhoz, amely a Linux kernel szintjén működik.

Az érzékelő esemény életciklusa

A HAL illesztőprogram nyers adatokat kap a hardver chip-től, kiszűri a zajt, és továbbítja őket felfelé a veremben — a SensorService (rendszerfolyamat) segítségével az alkalmazásba. Az adatok egy SensorEvent objektumként kerülnek továbbításra, amely egy float értékekből álló values tömböt és egy nanomásodpercben mért időbélyeget tartalmaz. Az események gyakorisága a kiválasztott kézbesítési módtól függ.

Esemény kézbesítési módok

A figyelő regisztrálásakor a fejlesztő megadja a kívánt késleltetést az események között a SENSOR_DELAY_NORMAL (200 ms), SENSOR_DELAY_UI (60 ms), SENSOR_DELAY_GAME (20 ms) és SENSOR_DELAY_FASTEST (0 ms — maximális gyakoriság) konstansok segítségével. A tényleges gyakoriság eltérhet — a rendszer optimalizálja az energiafogyasztást.

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

Kötegelt feldolgozás (Batch Processing)

Android 2.3-tól kezdve az érzékelők támogatják a kötegelt módot — az események egy FIFO pufferben gyűlnek össze, és egy csomagban kerülnek kézbesítésre. Ez lehetővé teszi a processzor számára, hogy hosszabb ideig alvó módban maradjon, akár 60%-kal csökkentve az energiafogyasztást. A puffer mérete az érzékelő chip-től függ, és a Sensor.fifoMaxEventCount mezőben van megadva.

SensorManager használata az érzékelők eléréséhez

SensorManager — rendszerszolgáltatás, amely a getSystemService(Context.SENSOR_SERVICE) segítségével érhető el. Metódusokat biztosít az érzékelők listájának lekéréséhez, egy adott alapértelmezett érzékelő lekéréséhez, valamint a figyelők regisztrálásához/lemondásához. SensorManager — singleton, egyetlen példány a teljes alkalmazáshoz.

Az érzékelő elérhetőségének ellenőrzése

Az érzékelő használata előtt ellenőrizni kell a meglétét. A getDefaultSensor(type) metódus null-t ad vissza, ha az érzékelő nem érhető el az eszközön. A null érték ellenőrzés nélkül NullPointerException-hez vezet a figyelő regisztrálásakor. Az összes érzékelő listáját a getSensorList(type) metódus adja vissza.

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

// Használat:
if (checkSensorAvailability(Sensor.TYPE_GYROSCOPE)) {
    Log.d("Sensor", "Giroszkóp elérhető")
}

Figyelő regisztrálása és lemondása

A figyelő a registerListener(listener, sensor, delay) segítségével regisztrálható. Fontos: a figyelő lemondását az onPause() metódusban kell elvégezni az unregisterListener(listener) segítségével. Ha ez nem történik meg, az alkalmazás továbbra is fogadja az érzékelő eseményeket, még háttérben is lemerítve az akkumulátort. Android 8+ figyelmeztetést jelenít meg a logcat-ben a nem regisztrált figyelőkről.

A pontosság változásának kezelése

Az onAccuracyChanged(sensor, accuracy) metódus akkor hívódik meg, amikor az érzékelő pontossága megváltozik. Értékek: SENSOR_STATUS_ACCURACY_HIGH, MEDIUM, LOW és UNRELIABLE. UNRELIABLE fogadásakor az érzékelő adatait figyelmen kívül kell hagyni a pontosság helyreállításáig. Például a magnetométer kalibrálást igényel — az eszköz rázása nyolcas alakban.

Kódpéldák érzékelőkkel való munkához Kotlinban

Nézzük meg a Sensors API használatának gyakorlati példáit Android alkalmazásokban Kotlin nyelven. Első példa — a képernyő tájolásának meghatározása gyorsulásmérő segítségével. Második — a magnetométer értékeinek leolvasása kalibrálással. Harmadik — lépésdetektor lépésszámláló használatával.

Az eszköz tájolásának meghatározása

A tájolás meghatározásához a gyorsulásmérő és a magnetométer kombinációját használják. A SensorManager.getRotationMatrix() metódus kiszámítja a forgási mátrixot, a getOrientation() pedig kinyeri a pitch, roll és azimuth szögeket. Azimuth (azimut) — a mágneses északhoz viszonyított szög radiánban.

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())

Lépésdetektor lépésszámlálóval

A lépésszámláló (TYPE_STEP_COUNTER) visszaadja a felhasználó által az eszköz utolsó újraindítása óta megtett lépések teljes számát. Az érzékelő hardver szinten működik — akkor is aktív, ha az alkalmazás nem fut. A munkamenetenkénti lépésszám lekéréséhez el kell menteni a kezdeti értéket, és ki kell számítani a különbséget.

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("Lépések", "Lépések a munkamenetben: $sessionSteps")
    }
}

Adaptív fényerő a fényérzékelő alapján

A fényérzékelő lehetővé teszi a felület környezeti feltételekhez való igazítását. Alacsony megvilágításnál (10 lx alatt) sötét témára lehet váltani. Erős napfénynél (10000 lx felett) — növelni a kontrasztot. A zaj szűréséhez mozgó átlag használatos az utolsó 5 érték alapján.

Virtuális érzékelők és fúziós algoritmusok

Az Android több olyan virtuális érzékelőt kínál, amelyeknek nincs közvetlen hardveres megfelelőjük. A virtuális érzékelő az értékeit fizikai érzékelők kombinációja alapján számítja ki. Ez csökkenti a fejlesztő terhelését — a rendszer maga implementálja az adatfúziós algoritmusokat.

Gravity és Linear Acceleration

A Gravity (TYPE_GRAVITY) érzékelő egy aluláteresztő (low-pass) szűrő segítségével kivonja a gravitációs összetevőt a gyorsulásmérő értékeiből. Linear Acceleration (TYPE_LINEAR_ACCELERATION) — fordítva, eltávolítja a gravitációt, és csak az eszköz lineáris gyorsulását hagyja meg. A Gravity és a Linear Acceleration összege adja a gyorsulásmérő nyers értékeit.

Rotation Vector

Rotation Vector — a legösszetettebb virtuális érzékelő. Egyesíti a giroszkóp (nagyfrekvenciás változások), a gyorsulásmérő (gravitációs vektor) és a magnetométer (északi irányhoz viszonyított tájolás) adatait. Az eredmény egy kvaternió, amely az eszköz abszolút térbeli tájolását írja le. AR alkalmazásokban és VR headsetekben használják.

Game Rotation Vector

Game Rotation Vector — a Rotation Vector egyszerűsített változata magnetométer használata nélkül. Ez alacsonyabb azimut pontosságot, de magasabb frissítési gyakoriságot és stabilitást biztosít. Játékokhoz ajánlott, ahol az alacsony késleltetés fontos, nem pedig az északi irányhoz viszonyított abszolút tájolás.

Energiafogyasztás optimalizálása érzékelőkkel való munka során

Az érzékelők az eszköz egyik legenergiaigényesebb alkatrészei. A gyorsulásmérő és a giroszkóp maximális lekérdezési gyakoriság mellett 3–4 óra folyamatos használat alatt lemerítheti az akkumulátort. Az érzékelőkkel való munka optimalizálása kritikus feladat minden olyan alkalmazás számára, amely a Sensors API-t használja.

Az optimális késleltetés kiválasztása

Ne használja a SENSOR_DELAY_FASTEST-et szükségtelenül. UI animációkhoz elegendő a SENSOR_DELAY_UI (60 ms). A képernyő tájolásának meghatározásához — SENSOR_DELAY_NORMAL (200 ms). Minél magasabb a gyakoriság, annál több időt tölt a processzor aktív állapotban. A NORMAL és FASTEST közötti különbség akár 10x-es az energiafogyasztásban.

Figyelők lemondása a háttérben

Android 8.0-tól (API 26) kezdve a háttér-alkalmazások csökkentett gyakorisággal kapják az érzékelő eseményeket. Android 12+ esetén a Motion és Position érzékelőkhöz való háttér-hozzáféréshez BODY_SENSORS_BACKGROUND engedély szükséges. Mondja le a figyelő regisztrációját, amikor az alkalmazás háttérmódba lép — ez meghosszabbítja az eszköz akkumulátorának élettartamát.

Kötegelt feldolgozás és FIFO puffer

Használja a kötegelt feldolgozást a registerListener(listener, sensor, delay, maxReportLatencyUs) metódus segítségével. A maxReportLatencyUs paraméter az események kézbesítésének maximális késleltetését adja meg mikroszekundumokban. 1000000 (1 másodperc) értéknél az események az érzékelő FIFO pufferében gyűlnek össze, és másodpercenként egyszer kerülnek kézbesítésre — a processzor ritkábban ébred fel alvó módból.

Gyakran Ismételt Kérdések

Milyen érzékelők vannak minden Android-eszközön?

A minimális készlet — gyorsulásmérő és magnetométer. Ez a két érzékelő az eszközök több mint 95%-ában megtalálható. Giroszkóp, fényérzékelő és közelségérzékelő — a modern modellek 70–80%-ában. A többi érzékelő (nyomás, hőmérséklet, páratartalom, lépésszámláló) ritkábban fordul elő, és az eszköz árkategóriájától függ.

Mi a különbség a TYPE_ACCELEROMETER és a TYPE_LINEAR_ACCELERATION között?

TYPE_ACCELEROMETER a teljes gyorsulást adja vissza, beleértve a gravitációt (9.8 m/s²). A TYPE_LINEAR_ACCELERATION a gravitáció nélküli gyorsulást adja vissza — csak az eszköz mozgásából származó gyorsulást. Ha az eszköz mozdulatlanul fekszik, a gyorsulásmérő 9.8 m/s²-t mutat a Z tengelyen, míg a Linear Acceleration 0-t minden tengelyen.

Hogyan ellenőrizhető, hogy az eszköz rendelkezik-e a szükséges érzékelővel?

Használja a getPackageManager().hasSystemFeature() metódust a megfelelő konstansokkal: FEATURE_SENSOR_ACCELEROMETER, FEATURE_SENSOR_GYROSCOPE, FEATURE_SENSOR_PROXIMITY és mások. Alternatív módszer — hívja meg a getDefaultSensor(type) metódust, és ellenőrizze az eredményt null-ra. Az első módszer előnyösebb az inicializálási szakaszban történő ellenőrzéshez.

Miért ugrálnak az érzékelő értékei, és hogyan lehet simítani őket?

Az érzékelőktől származó nyers adatok zajt tartalmaznak. A simításhoz használjon aluláteresztő (low-pass) szűrőt: newValue = alpha * rawValue + (1 — alpha) * previousValue. Az alpha = 0.1–0.3 együttható jó egyensúlyt biztosít a reagálóképesség és a simaság között. A giroszkóp esetében felüláteresztő (high-pass) szűrőt is alkalmaznak a nulla eltolódás eltávolítására.

Használhatók az érzékelők háttérben?

Igen, de korlátozásokkal. Android 8.0-tól kezdve az érzékelő események gyakorisága csökken a háttér-alkalmazások számára. Android 12-től kezdve a BODY_SENSORS_BACKGROUND engedély szükséges az érzékelők háttérben történő eléréséhez. Háttérmunkához ajánlott a Foreground Service használata értesítéssel.

Összefoglalás

  • Sensors API — egységes Android interfész az eszköz hardveres érzékelőitől származó adatok lekéréséhez a SensorManageren keresztül.
  • Három kategória — Motion (gyorsulásmérő, giroszkóp), Position (magnetométer) és Environment (fény, nyomás) eltérő működési elvekkel és alkalmazásokkal.
  • Virtuális érzékelők — Gravity, Linear Acceleration és Rotation Vector fizikai érzékelők adatainak fúzióján alapulnak, hardveres megfelelő nélkül.
  • Optimalizálás — a megfelelő késleltetés kiválasztása (SENSOR_DELAY_NORMAL, UI, GAME, FASTEST) és a kötegelt feldolgozás használata akár 60%-kal csökkenti az energiafogyasztást.
  • Korlátozások — Android 8+ csökkenti az érzékelők gyakoriságát a háttérben, Android 12+ BODY_SENSORS_BACKGROUND engedélyt igényel a háttér-hozzáféréshez.
  • Alapvető ellenőrzés — a figyelő regisztrálása előtt ellenőrizze az érzékelő elérhetőségét a getDefaultSensor vagy hasSystemFeature segítségével.
  • Használjon low-pass szűrőt a zaj simításához, és mondja le a figyelő regisztrációját háttérbe lépéskor az akkumulátor kímélése érdekében.

Kulcsrakész mobilalkalmazást fejlesztünk

Az IT Sectr 2017 óta készít iOS és Android alkalmazásokat induló vállalkozásoknak és vállalkozásoknak. Tanácsot adunk, és a legjobb megoldást javasoljuk.

Projekt megbeszélése

Olvassa el is